diff --git a/.dockerignore b/.dockerignore deleted file mode 100644 index c2658d7..0000000 --- a/.dockerignore +++ /dev/null @@ -1 +0,0 @@ -node_modules/ diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d823768..c2e3684 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -20,4 +20,37 @@ jobs: - name: Install dependencies run: npm ci - name: Compile code and run test coverage + run: npm run hardhat:coverage + + foundry: + strategy: + fail-fast: true + + name: Foundry Tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + - uses: actions/setup-node@v3 + with: + node-version: 16 + - name: Install dependencies + run: npm ci + - name: Install LCOV + run: sudo apt-get -y install lcov + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + with: + version: nightly + - name: Run Forge build + run: | + forge --version + forge build + - name: Run Forge tests + run: | + cp .env.example .env + source .env + forge test -vvv + - name: Run Full Merged Coverage run: npm run coverage diff --git a/.gitignore b/.gitignore index 1be6b0d..5a77d23 100644 --- a/.gitignore +++ b/.gitignore @@ -17,12 +17,24 @@ build/ /tasks/collect.ts /tasks/test-module.ts -/coverage +/coverage* coverage.json .coverage_artifacts .coverage_cache .coverage_contracts +lcov* addresses.json -contracts/core/modules/follow/SecretCodeFollowModule.sol \ No newline at end of file +# Compiler files +forge-cache/ +out/ + +# Ignores development broadcast logs +!/broadcast +/broadcast/*/31337/ +/broadcast/**/dry-run/ + +contracts/core/modules/follow/SecretCodeFollowModule.sol + +.DS_Store diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..e69de29 diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index da730a9..0000000 --- a/Dockerfile +++ /dev/null @@ -1,21 +0,0 @@ -# syntax=docker/dockerfile:1.3 -FROM ethereum/solc:0.8.7 as build-deps - -FROM node:16 as build-packages - -COPY package*.json ./ -COPY tsconfig*.json ./ - -RUN npm ci --quiet - -FROM node:16 - -WORKDIR /src - -COPY --from=build-deps /usr/bin/solc /usr/bin/solc -COPY --from=build-packages /node_modules /node_modules -COPY docker-entrypoint.sh /docker-entrypoint.sh - -USER node - -ENTRYPOINT ["sh", "/docker-entrypoint.sh"] \ No newline at end of file diff --git a/TestsList.md b/TestsList.md new file mode 100644 index 0000000..1069454 --- /dev/null +++ b/TestsList.md @@ -0,0 +1,526 @@ +Collecting +Generic +Negatives +// TODO: Move to only follows module test? +[?] User two should fail to collect without being a follower +[?] User two should follow, then transfer the followNFT and fail to collect +[X] User two should fail to collect a nonexistent publication +Scenarios +// TODO: Move to only follows module test? +[?] Collecting should work if the collector is the publication owner even when he is not following himself and follow NFT was not deployed +[?] Collecting should work if the collector is the publication owner even when he is not following himself and follow NFT was deployed +[ ] Should return the expected token IDs when collecting publications +[ ] UserTwo should follow, then collect, receive a collect NFT with the expected properties +[X] UserTwo should follow, then mirror, then collect on their mirror, receive a collect NFT with expected properties +[ ] UserTwo should follow, then mirror, mirror their mirror then collect on their latest mirror, receive a collect NFT with expected properties +Meta-tx +Negatives +[X] TestWallet should fail to collect with sig with signature deadline mismatch +[X] TestWallet should fail to collect with sig with invalid deadline +[X] TestWallet should fail to collect with sig with invalid nonce +[?] TestWallet should fail to collect with sig without being a follower +[ ] TestWallet should sign attempt to collect with sig, cancel via empty permitForAll, fail to collect with sig +Scenarios +// TODO: Move to only follows module test? +[?] TestWallet should follow, then collect with sig, receive a collect NFT with expected properties +[X] TestWallet should follow, mirror, then collect with sig on their mirror + +Following +Generic +Negatives +[X] UserTwo should fail to follow a nonexistent profile +[X] UserTwo should fail to follow with array mismatch +[X] UserTwo should fail to follow a profile that has been burned +[X] UserTwo should fail to follow profile with id 0 +Scenarios +[X] UserTwo should follow profile 1, receive a followNFT with ID 1, followNFT properties should be correct +[-] UserTwo should follow profile 1 twice, receiving followNFTs with IDs 1 and 2 +[-] UserTwo should follow profile 1 3 times in the same call, receive IDs 1,2 and 3 +[X] Should return the expected token IDs when following profiles +Meta-tx +Negatives +[X] TestWallet should fail to follow with sig with signature deadline mismatch +[X] TestWallet should fail to follow with sig with invalid deadline +[X] TestWallet should fail to follow with sig with invalid nonce +[X] TestWallet should fail to follow a nonexistent profile with sig +[-] TestWallet should sign attempt to follow with sig, cancel with empty permitForAll, then fail to follow with sig +Scenarios +[X] TestWallet should follow profile 1 with sig, receive a follow NFT with ID 1, follow NFT name and symbol should be correct +[X] TestWallet should follow profile 1 with sig twice in the same call, receive follow NFTs with IDs 1 and 2 + +Governance Functions +Negatives +[X] User should not be able to call governance functions +Scenarios +[X] Governance should successfully whitelist and unwhitelist modules +[X] Governance should successfully change the governance address + +Multi-State Hub +Common +Negatives +[X] User should fail to set the state on the hub +[X] User should fail to set the emergency admin +[X] Governance should set user as emergency admin, user should fail to set protocol state to Unpaused +[X] Governance should set user as emergency admin, user should fail to set protocol state to PublishingPaused or Paused from Paused +Scenarios +[X] Governance should set user as emergency admin, user sets protocol state but fails to set emergency admin, governance sets emergency admin to the zero address, user fails to set protocol state +[X] Governance should set the protocol state, fetched protocol state should be accurate +[X] Governance should set user as emergency admin, user should set protocol state to PublishingPaused, then Paused, then fail to set it to PublishingPaused +Paused State +Scenarios +[X] User should create a profile, governance should pause the hub, transferring the profile should fail +[X] Governance should pause the hub, profile creation should fail, then governance unpauses the hub and profile creation should work +[X] Governance should pause the hub, setting follow module should fail, then governance unpauses the hub and setting follow module should work +[X] Governance should pause the hub, setting follow module with sig should fail, then governance unpauses the hub and setting follow module with sig should work +// Replaced dispatcher with DelegatedExecutor for the following two tests: +[X] Governance should pause the hub, setting dispatcher should fail, then governance unpauses the hub and setting dispatcher should work +[X] Governance should pause the hub, setting dispatcher with sig should fail, then governance unpauses the hub and setting dispatcher with sig should work +[X] Governance should pause the hub, setting profile URI should fail, then governance unpauses the hub and setting profile URI should work +[X] Governance should pause the hub, setting profile URI with sig should fail, then governance unpauses the hub and setting profile URI should work +[X] Governance should pause the hub, setting follow NFT URI should fail, then governance unpauses the hub and setting follow NFT URI should work +[X] Governance should pause the hub, setting follow NFT URI with sig should fail, then governance unpauses the hub and setting follow NFT URI should work +[X] Governance should pause the hub, posting should fail, then governance unpauses the hub and posting should work +[X] Governance should pause the hub, posting with sig should fail, then governance unpauses the hub and posting with sig should work +[X] Governance should pause the hub, commenting should fail, then governance unpauses the hub and commenting should work +[X] Governance should pause the hub, commenting with sig should fail, then governance unpauses the hub and commenting with sig should work +[X] Governance should pause the hub, mirroring should fail, then governance unpauses the hub and mirroring should work +[X] Governance should pause the hub, mirroring with sig should fail, then governance unpauses the hub and mirroring with sig should work +[X] Governance should pause the hub, burning should fail, then governance unpauses the hub and burning should work +[X] Governance should pause the hub, following should fail, then governance unpauses the hub and following should work +[X] Governance should pause the hub, following with sig should fail, then governance unpauses the hub and following with sig should work +[X] Governance should pause the hub, collecting should fail, then governance unpauses the hub and collecting should work +[X] Governance should pause the hub, collecting with sig should fail, then governance unpauses the hub and collecting with sig should work +PublishingPaused State +Scenarios +[X] Governance should pause publishing, profile creation should work +[X] Governance should pause publishing, setting follow module should work +[X] Governance should pause publishing, setting follow module with sig should work +[X] Governance should pause publishing, setting dispatcher should work +[X] Governance should pause publishing, setting dispatcher with sig should work +[X] Governance should pause publishing, setting profile URI should work +[X] Governance should pause publishing, setting profile URI with sig should work +[X] Governance should pause publishing, posting should fail, then governance unpauses the hub and posting should work +[X] Governance should pause publishing, posting with sig should fail, then governance unpauses the hub and posting with sig should work +[X] Governance should pause publishing, commenting should fail, then governance unpauses the hub and commenting should work +[X] Governance should pause publishing, commenting with sig should fail, then governance unpauses the hub and commenting with sig should work +[X] Governance should pause publishing, mirroring should fail, then governance unpauses the hub and mirroring should work +[X] Governance should pause publishing, mirroring with sig should fail, then governance unpauses the hub and mirroring with sig should work +[X] Governance should pause publishing, burning should work +[X] Governance should pause publishing, following should work +[X] Governance should pause publishing, following with sig should work +[X] Governance should pause publishing, collecting should work +[X] Governance should pause publishing, collecting with sig should work + +Publishing Comments +Generic +Negatives +[X] UserTwo should fail to publish a comment to a profile owned by User +[X] User should fail to comment with an unwhitelisted collect module +[X] User should fail to comment with an unwhitelisted reference module +[-] (Module Tests) User should fail to comment with invalid collect module data format +[-] (Module Tests) User should fail to comment with invalid reference module data format +[X] User should fail to comment on a publication that does not exist +[X] User should fail to comment on the same comment they are creating (pubId = 2, commentCeption) +Scenarios +[X] User should create a comment with empty collect module data, reference module, and reference module data, fetched comment data should be accurate +[X] Should return the expected token IDs when commenting publications +[X] User should create a post using the mock reference module as reference module, then comment on that post +Meta-tx +Negatives +[X] Testwallet should fail to comment with sig with signature deadline mismatch +[X] Testwallet should fail to comment with sig with invalid deadline +[X] Testwallet should fail to comment with sig with invalid nonce +[X] Testwallet should fail to comment with sig with unwhitelisted collect module +[X] TestWallet should fail to comment with sig with unwhitelisted reference module +[X] TestWallet should fail to comment with sig on a publication that does not exist +[X] TestWallet should fail to comment with sig on the comment they are creating (commentCeption) +[X] TestWallet should sign attempt to comment with sig, cancel via empty permitForAll, then fail to comment with sig +Scenarios +[X] TestWallet should comment with sig, fetched comment data should be accurate + +Publishing mirrors +Generic +Negatives +[X] UserTwo should fail to publish a mirror to a profile owned by User +[X] User should fail to mirror with an unwhitelisted reference module +[-] (Module Tests) User should fail to mirror with invalid reference module data format +[X] User should fail to mirror a publication that does not exist +Scenarios +[X] Should return the expected token IDs when mirroring publications +[X] User should create a mirror with empty reference module and reference module data, fetched mirror data should be accurate +[X] User should mirror a mirror with empty reference module and reference module data, fetched mirror data should be accurate and point to the original post +[X] User should create a post using the mock reference module as reference module, then mirror that post +Meta-tx +Negatives +[X] Testwallet should fail to mirror with sig with signature deadline mismatch +[X] Testwallet should fail to mirror with sig with invalid deadline +[X] Testwallet should fail to mirror with sig with invalid nonce +[X] Testwallet should fail to mirror with sig with unwhitelisted reference module +[X] TestWallet should fail to mirror a publication with sig that does not exist yet +[X] TestWallet should sign attempt to mirror with sig, cancel via empty permitForAll, then fail to mirror with sig +Scenarios +[X] Testwallet should mirror with sig, fetched mirror data should be accurate +[X] TestWallet should mirror a mirror with sig, fetched mirror data should be accurate + +Publishing Posts +Generic +Negatives +[X] UserTwo should fail to post to a profile owned by User +[X] User should fail to post with an unwhitelisted collect module +[X] User should fail to post with an unwhitelisted reference module +[-] (Modules tests) User should fail to post with invalid collect module data format +[-] (Modules Tests) User should fail to post with invalid reference module data format +Scenarios +[X] Should return the expected token IDs when ~~mirroring~~ posting publications +[X] User should create a post with empty collect and reference module data, fetched post data should be accurate +[X] User should create a post with a whitelisted collect and reference module +Meta-tx +Negatives +[X] Testwallet should fail to post with sig with signature deadline mismatch +[X] Testwallet should fail to post with sig with invalid deadline +[X] Testwallet should fail to post with sig with invalid nonce +[X] Testwallet should fail to post with sig with an unwhitelisted collect module +[X] Testwallet should fail to post with sig with an unwhitelisted reference module +[X] (Replaced it with another post with same nonce) TestWallet should sign attempt to post with sig, cancel via empty permitForAll, then fail to post with sig +[ ] TestWallet should deploy bad EIP1271 implementer, transfer profile to it, then fail to post with sig +Scenarios +[X] TestWallet should post with sig, fetched post data should be accurate +[ ] TestWallet should deploy EIP1271 implementer, transfer profile to it, then post with sig + +Default profile Functionality +Generic +Negatives +[X] UserTwo should fail to set the default profile as a profile owned by user 1 +Scenarios +[X] User should set the default profile +[X] User should set the default profile and then be able to unset it +[X] User should set the default profile and then be able to change it to another +[X] User should set the default profile and then transfer it, their default profile should be unset +Meta-tx +Negatives +[X] TestWallet should fail to set default profile with sig with signature deadline mismatch +[X] TestWallet should fail to set default profile with sig with invalid deadline +[X] TestWallet should fail to set default profile with sig with invalid nonce + + + +[-] TestWallet should sign attempt to set default profile with sig, cancel with empty permitForAll, then fail to set default profile with sig +Scenarios +[X] TestWallet should set the default profile with sig +[X] TestWallet should set the default profile with sig and then be able to unset it +[X] TestWallet should set the default profile and then be able to change it to another + +Dispatcher Functionality +Generic +Negatives +[ ] UserTwo should fail to set dispatcher on profile owned by user 1 +[ ] UserTwo should fail to publish on profile owned by user 1 without being a dispatcher +Scenarios +[ ] User should set user two as a dispatcher on their profile, user two should post, comment and mirror +Meta-tx +Negatives +[ ] TestWallet should fail to set dispatcher with sig with signature deadline mismatch +[ ] TestWallet should fail to set dispatcher with sig with invalid deadline +[ ] TestWallet should fail to set dispatcher with sig with invalid nonce +[ ] TestWallet should sign attempt to set dispatcher with sig, cancel via empty permitForAll, fail to set dispatcher with sig +Scenarios +[ ] TestWallet should set user two as dispatcher for their profile, user two should post, comment and mirror + +Profile Creation +Generic +Negatives +[ ] User should fail to create a profile with a handle longer than 31 bytes +[ ] User should fail to create a profile with an empty handle (0 length bytes) +[ ] User should fail to create a profile with a handle with a capital letter +[ ] User should fail to create a profile with a handle with an invalid character +[ ] User should fail to create a profile with a unwhitelisted follow module +[ ] User should fail to create a profile with with invalid follow module data format +[ ] User should fail to create a profile when they are not a whitelisted profile creator +[ ] User should fail to create a profile with invalid image URI length +Scenarios +[ ] User should be able to create a profile with a handle, receive an NFT and the handle should resolve to the NFT ID, userTwo should do the same +[ ] Should return the expected token IDs when creating profiles +[ ] User should be able to create a profile with a handle including "-" and "\_" characters +[ ] User should be able to create a profile with a handle 16 bytes long, then fail to create with the same handle, and create again with a different handle +[ ] User should be able to create a profile with a whitelisted follow module +[ ] User should create a profile for userTwo + +Profile URI Functionality +Generic +Negatives +[ ] UserTwo should fail to set the profile URI on profile owned by user 1 +[ ] UserTwo should fail to set the profile URI on profile owned by user 1 +[ ] UserTwo should fail to change the follow NFT URI for profile one +Scenarios +[ ] User should have a custom image tokenURI after setting the profile imageURI +[ ] User should set a custom image URI under 32 bytes of length, profile image URI should be accurate +[ ] Default image should be used when no imageURI set +[ ] Default image should be used when imageURI contains double-quotes +[ ] Should return the correct tokenURI after transfer +[ ] Should return the correct tokenURI after a follow +[ ] User should set user two as a dispatcher on their profile, user two should set the profile URI +[ ] User should follow profile 1, user should change the follow NFT URI, URI is accurate before and after the change +Meta-tx +Negatives +[ ] TestWallet should fail to set profile URI with sig with signature deadline mismatch +[ ] TestWallet should fail to set profile URI with sig with invalid deadline +[ ] TestWallet should fail to set profile URI with sig with invalid nonce +[ ] TestWallet should sign attempt to set profile URI with sig, cancel with empty permitForAll, then fail to set profile URI with sig +[ ] TestWallet should fail to set the follow NFT URI with sig with signature deadline mismatch +[ ] TestWallet should fail to set the follow NFT URI with sig with invalid deadline +[ ] TestWallet should fail to set the follow NFT URI with sig with invalid nonce +[ ] TestWallet should sign attempt to set follow NFT URI with sig, cancel with empty permitForAll, then fail to set follow NFT URI with sig +Scenarios +[ ] TestWallet should set the profile URI with sig +[ ] TestWallet should set the follow NFT URI with sig + +Setting Follow Module +Generic +Negatives +[X] UserTwo should fail to set the follow module for the profile owned by User +[X] User should fail to set a follow module that is not whitelisted +[X] User should fail to set a follow module with invalid follow module data format +Scenarios +[X] User should set a whitelisted follow module, fetching the profile follow module should return the correct address, user then sets it to the zero address and fetching returns the zero address +Meta-tx +Negatives +[X] TestWallet should fail to set a follow module with sig with signature deadline mismatch +[X] TestWallet should fail to set a follow module with sig with invalid deadline +[X] TestWallet should fail to set a follow module with sig with invalid nonce +[X] TestWallet should fail to set a follow module with sig with an unwhitelisted follow module +[X] TestWallet should sign attempt to set follow module with sig, then cancel with empty permitForAll, then fail to set follow module with sig +Scenarios +[X] TestWallet should set a whitelisted follow module with sig, fetching the profile follow module should return the correct address + +Collect NFT +Negatives +[ ] User should fail to reinitialize the collect NFT +[ ] User should fail to mint on the collect NFT +[ ] UserTwo should fail to burn user's collect NFT +[ ] User should fail to get the URI for a token that does not exist +[ ] User should fail to change the royalty percentage if he is not the owner of the publication +[ ] User should fail to change the royalty percentage if the value passed exceeds the royalty basis points +Scenarios +[ ] Collect NFT URI should be valid +[ ] Collect NFT source publication pointer should be accurate +[ ] User should burn their collect NFT +[ ] Default royalties are set to 10% +[ ] User should be able to change the royalties if owns the profile and passes a valid royalty percentage in basis points +[ ] User should be able to get the royalty info even over a token that does not exist yet +[ ] Publication owner should be able to remove royalties by setting them as zero +[ ] If the profile authoring the publication is transferred the royalty info now returns the new owner as recipient + +Follow NFT +generic +Negatives +[ ] User should follow, and fail to re-initialize the follow NFT +[-] User should follow, userTwo should fail to burn user's follow NFT +[-] User should follow, then fail to mint a follow NFT directly +[-] User should follow, then fail to get the power at a future block +[-] user should follow, then fail to get the URI for a token that does not exist +Scenarios +[-] User should follow, then burn their follow NFT, governance power is zero before and after +[-] User should follow, delegate to themself, governance power should be zero before the last block, and 1 at the current block +[-] User and userTwo should follow, governance power should be zero, then users delegate multiple times, governance power should be accurate throughout +[-] User and userTwo should follow, delegate to themselves, 10 blocks later user delegates to userTwo, 10 blocks later both delegate to user, governance power should be accurate throughout +[-] user and userTwo should follow, user delegates to userTwo twice, governance power should be accurate +[-] User and userTwo should follow, then transfer their NFTs to the helper contract, then the helper contract batch delegates to user one, then user two, governance power should be accurate +[-] user should follow, then get the URI for their token, URI should be accurate +meta-tx +negatives +[-] TestWallet should fail to delegate with sig with signature deadline mismatch +[-] TestWallet should fail to delegate with sig with invalid deadline +[-] TestWallet should fail to delegate with sig with invalid nonce +[-] TestWallet should sign attempt to delegate by sig, cancel with empty permitForAll, then fail to delegate by sig +Scenarios +[-] TestWallet should delegate by sig to user, governance power should be accurate before and after + +Lens NFT Base Functionality +generic +[ ] Domain separator fetched from contract should be accurate +meta-tx +Negatives +[ ] TestWallet should fail to permit with zero spender +[ ] TestWallet should fail to permit with invalid token ID +[ ] TestWallet should fail to permit with signature deadline mismatch +[ ] TestWallet should fail to permit with invalid deadline +[ ] TestWallet should fail to permit with invalid nonce +[ ] TestWallet should sign attempt to permit, cancel with empty permitForAll, then fail to permit +[ ] TestWallet should fail to permitForAll with zero spender +[ ] TestWallet should fail to permitForAll with signature deadline mismatch +[ ] TestWallet should fail to permitForAll with invalid deadline +[ ] TestWallet should fail to permitForAll with invalid nonce +[ ] TestWallet should sign attempt to permitForAll, cancel with empty permitForAll, then fail to permitForAll +[ ] TestWallet should fail to burnWithSig with invalid token ID +[ ] TestWallet should fail to burnWithSig with signature deadline mismatch +[ ] TestWallet should fail to burnWithSig with invalid deadline +[ ] TestWallet should fail to burnWithSig with invalid nonce +[ ] TestWallet should sign attempt to burnWithSig, cancel with empty permitForAll, then fail to burnWithSig +[ ] TestWallet should deploy bad EIP1271 implementer, transfer NFT to it, sign message and permit user, permit should fail with invalid sig +Scenarios +[ ] TestWallet should permit user, user should transfer NFT, send back NFT and fail to transfer it again +[ ] TestWallet should permitForAll user, user should transfer NFT, send back NFT and transfer it again +[ ] TestWallet should sign burnWithSig, user should submit and burn NFT +[ ] TestWallet should deploy EIP1271 implementer, transfer NFT to it, sign message and permit user, user should transfer NFT, send back NFT and fail to transfer it again + +deployment validation +[ ] Should fail to deploy a LensHub implementation with zero address follow NFT impl +[ ] Should fail to deploy a LensHub implementation with zero address collect NFT impl +[ ] Should fail to deploy a FollowNFT implementation with zero address hub +[ ] Should fail to deploy a CollectNFT implementation with zero address hub +[ ] Deployer should not be able to initialize implementation due to address(this) check +[ ] User should fail to initialize lensHub proxy after it's already been initialized via the proxy constructor +[ ] Deployer should deploy a LensHub implementation, a proxy, initialize it, and fail to initialize it again +[ ] User should not be able to call admin-only functions on proxy (should fallback) since deployer is admin +[ ] Deployer should be able to call admin-only functions on proxy +[ ] Deployer should transfer admin to user, deployer should fail to call admin-only functions, user should call admin-only functions +[ ] Should fail to deploy a fee collect module with zero address hub +[ ] Should fail to deploy a fee collect module with zero address module globals +[ ] Should fail to deploy a fee follow module with zero address hub +[ ] Should fail to deploy a fee follow module with zero address module globals +[ ] Should fail to deploy module globals with zero address governance +[ ] Should fail to deploy module globals with zero address treasury +[ ] Should fail to deploy module globals with treausury fee > BPS_MAX / 2 +[ ] Should fail to deploy a fee module with treasury fee equal to or higher than maximum BPS +[ ] Validates LensHub name & symbol + +Events +Misc +[X] Proxy initialization should emit expected events +Hub Governance +[X] Governance change should emit expected event +[X] Emergency admin change should emit expected event +[X] Protocol state change by governance should emit expected event +[X] Protocol state change by emergency admin should emit expected events +[X] Follow module whitelisting functions should emit expected event +[X] Reference module whitelisting functions should emit expected event +[X] Collect module whitelisting functions should emit expected event +Hub Interaction +[X] Profile creation for other user should emit the correct events +[X] Profile creation should emit the correct events +[X] Setting follow module should emit correct events +[X] Setting dispatcher should emit correct events +[X] Posting should emit the correct events +[X] Commenting should emit the correct events +[X] Mirroring should emit the correct events +[X] Following should emit correct events +[X] Collecting should emit correct events +[X] Collecting from a mirror should emit correct events +Module Globals Governance +[X] Governance change should emit expected event +[X] Treasury change should emit expected event +[X] Treasury fee change should emit expected event +[X] Currency whitelisting should emit expected event + +Misc +NFT Transfer Emitters +[X] User should not be able to call the follow NFT transfer event emitter function +[X] User should not be able to call the collect NFT transfer event emitter function +Lens Hub Misc +[ ] UserTwo should fail to burn profile owned by user without being approved +[ ] User should burn profile owned by user +[ ] UserTwo should burn profile owned by user if approved +[ ] Governance getter should return proper address +[ ] Profile handle getter should return the correct handle +[ ] Profile dispatcher getter should return the zero address when no dispatcher is set +[ ] Profile creator whitelist getter should return expected values +[ ] Profile dispatcher getter should return the correct dispatcher address when it is set, then zero after it is transferred +[ ] Profile follow NFT getter should return the zero address before the first follow, then the correct address afterwards +[ ] Profile follow module getter should return the zero address, then the correct follow module after it is set +[ ] Profile publication count getter should return zero, then the correct amount after some publications +[ ] Follow NFT impl getter should return the correct address +[ ] Collect NFT impl getter should return the correct address +[ ] Profile tokenURI should return the accurate URI +[ ] Publication reference module getter should return the correct reference module (or zero in case of no reference module) +[ ] Publication pointer getter should return an empty pointer for posts +[ ] Publication pointer getter should return the correct pointer for comments +[ ] Publication pointer getter should return the correct pointer for mirrors +[ ] Publication content URI getter should return the correct URI for posts +[ ] Publication content URI getter should return the correct URI for comments +[ ] Publication content URI getter should return the correct URI for mirrors +[ ] Publication collect module getter should return the correct collectModule for posts +[ ] Publication collect module getter should return the correct collectModule for comments +[ ] Publication collect module getter should return the zero address for mirrors +[ ] Publication type getter should return the correct publication type for all publication types, or nonexistent +[ ] Profile getter should return accurate profile parameters +Follow Module Misc +[ ] User should fail to call processFollow directly on a follow module inheriting from the FollowValidatorFollowModuleBase +[ ] Follow module following check when there are no follows, and thus no deployed Follow NFT should return false +[ ] Follow module following check with zero ID input should return false after another address follows, but not the queried address +[ ] Follow module following check with specific ID input should revert after following, but the specific ID does not exist yet +[ ] Follow module following check with specific ID input should return false if another address owns the specified follow NFT +[ ] Follow module following check with specific ID input should return true if the queried address owns the specified follow NFT +Collect Module Misc +[ ] Should fail to call processCollect directly on a collect module inheriting from the FollowValidationModuleBase contract +Module Globals +Negatives +[X] User should fail to set the governance address on the module globals +[X] User should fail to set the treasury on the module globals +[X] User should fail to set the treasury fee on the module globals +Scenarios +[X] Governance should set the governance address on the module globals +[X] Governance should set the treasury on the module globals +[X] Governance should set the treasury fee on the module globals +[X] Governance should fail to whitelist the zero address as a currency +[X] Governance getter should return expected address +[X] Treasury getter should return expected address +[X] Treasury fee getter should return the expected fee +UI Data Provider +[ ] UI Data Provider should return expected values +LensPeriphery +ToggleFollowing +Generic +Negatives +[ ] UserTwo should fail to toggle follow with an incorrect profileId +[ ] UserTwo should fail to toggle follow with array mismatch +[ ] UserTwo should fail to toggle follow from a profile that has been burned +[ ] UserTwo should fail to toggle follow for a followNFT that is not owned by them +Scenarios +[ ] UserTwo should toggle follow with true value, correct event should be emitted +[ ] User should create another profile, userTwo follows, then toggles both, one true, one false, correct event should be emitted +[ ] UserTwo should toggle follow with false value, correct event should be emitted +Meta-tx +Negatives +[ ] TestWallet should fail to toggle follow with sig with signature deadline mismatch +[ ] TestWallet should fail to toggle follow with sig with invalid deadline +[ ] TestWallet should fail to toggle follow with sig with invalid nonce +[ ] TestWallet should fail to toggle follow a nonexistent profile with sig +Scenarios +[ ] TestWallet should toggle follow profile 1 to true with sig, correct event should be emitted +[ ] TestWallet should toggle follow profile 1 to false with sig, correct event should be emitted +// TODO: The whole section is questionable (removed in foundry branch) +Profile Metadata URI +Generic +Negatives +[X] User two should fail to set profile metadata URI for a profile that is not theirs while they are not the dispatcher +Scenarios +[X] User should set user two as dispatcher, user two should set profile metadata URI for user one's profile, fetched data should be accurate +[X] Setting profile metadata should emit the correct event +[X] Setting profile metadata via dispatcher should emit the correct event +Meta-tx +Negatives +[X] TestWallet should fail to set profile metadata URI with sig with signature deadline mismatch +[X] TestWallet should fail to set profile metadata URI with sig with invalid deadline +[X] TestWallet should fail to set profile metadata URI with sig with invalid nonce +Scenarios +[X] TestWallet should set profile metadata URI with sig, fetched data should be accurate and correct event should be emitted + +Mock Profile Creation Proxy +Negatives +[ ] Should fail to create profile if handle length before suffix does not reach minimum length +[ ] Should fail to create profile if handle contains an invalid character before the suffix +[ ] Should fail to create profile if handle starts with a dash, underscore or period +Scenarios +[ ] Should be able to create a profile using the whitelisted proxy, received NFT should be valid + +Profile Creation Proxy +Negatives +[ ] Should fail to create profile if handle length before suffix does not reach minimum length +[ ] Should fail to create profile if handle contains an invalid character before the suffix +[ ] Should fail to create profile if handle starts with a dash, underscore or period +Scenarios +[ ] Should be able to create a profile using the whitelisted proxy, received NFT should be valid + +Upgradeability +[ ] Should fail to initialize an implementation with the same revision +[ ] Should upgrade and set a new variable's value, previous storage is unchanged, new value is accurate diff --git a/contracts/core/CollectNFT.sol b/contracts/core/CollectNFT.sol index 2b46131..5927846 100644 --- a/contracts/core/CollectNFT.sol +++ b/contracts/core/CollectNFT.sol @@ -1,14 +1,15 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; +import {ERC2981CollectionRoyalties} from './base/ERC2981CollectionRoyalties.sol'; +import {ERC721Enumerable} from './base/ERC721Enumerable.sol'; +import {Errors} from '../libraries/Errors.sol'; +import {Events} from '../libraries/Events.sol'; import {ICollectNFT} from '../interfaces/ICollectNFT.sol'; import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; import {ILensHub} from '../interfaces/ILensHub.sol'; -import {Errors} from '../libraries/Errors.sol'; -import {Events} from '../libraries/Events.sol'; import {LensNFTBase} from './base/LensNFTBase.sol'; -import {ERC721Enumerable} from './base/ERC721Enumerable.sol'; /** * @title CollectNFT @@ -17,7 +18,7 @@ import {ERC721Enumerable} from './base/ERC721Enumerable.sol'; * @notice This is the NFT contract that is minted upon collecting a given publication. It is cloned upon * the first collect for a given publication, and the token URI points to the original publication's contentURI. */ -contract CollectNFT is LensNFTBase, ICollectNFT { +contract CollectNFT is LensNFTBase, ERC2981CollectionRoyalties, ICollectNFT { address public immutable HUB; uint256 internal _profileId; @@ -26,11 +27,7 @@ contract CollectNFT is LensNFTBase, ICollectNFT { bool private _initialized; - uint256 internal _royaltyBasisPoints; - - // bytes4(keccak256('royaltyInfo(uint256,uint256)')) == 0x2a55205a - bytes4 internal constant INTERFACE_ID_ERC2981 = 0x2a55205a; - uint16 internal constant BASIS_POINTS = 10000; + uint256 internal _royaltiesInBasisPoints; // We create the CollectNFT with the pre-computed HUB address before deploying the hub proxy in order // to initialize the hub proxy at construction. @@ -49,7 +46,7 @@ contract CollectNFT is LensNFTBase, ICollectNFT { ) external override { if (_initialized) revert Errors.Initialized(); _initialized = true; - _royaltyBasisPoints = 1000; // 10% of royalties + _setRoyalty(1000); // 10% of royalties _profileId = profileId; _pubId = pubId; super._initialize(name, symbol); @@ -76,42 +73,6 @@ contract CollectNFT is LensNFTBase, ICollectNFT { return ILensHub(HUB).getContentURI(_profileId, _pubId); } - /** - * @notice Changes the royalty percentage for secondary sales. Can only be called publication's - * profile owner. - * - * @param royaltyBasisPoints The royalty percentage meassured in basis points. Each basis point - * represents 0.01%. - */ - function setRoyalty(uint256 royaltyBasisPoints) external { - if (IERC721(HUB).ownerOf(_profileId) == msg.sender) { - if (royaltyBasisPoints > BASIS_POINTS) { - revert Errors.InvalidParameter(); - } else { - _royaltyBasisPoints = royaltyBasisPoints; - } - } else { - revert Errors.NotProfileOwner(); - } - } - - /** - * @notice Called with the sale price to determine how much royalty - * is owed and to whom. - * - * @param tokenId The token ID of the NFT queried for royalty information. - * @param salePrice The sale price of the NFT specified. - * @return A tuple with the address who should receive the royalties and the royalty - * payment amount for the given sale price. - */ - function royaltyInfo(uint256 tokenId, uint256 salePrice) - external - view - returns (address, uint256) - { - return (IERC721(HUB).ownerOf(_profileId), (salePrice * _royaltyBasisPoints) / BASIS_POINTS); - } - /** * @dev See {IERC165-supportsInterface}. */ @@ -119,10 +80,30 @@ contract CollectNFT is LensNFTBase, ICollectNFT { public view virtual - override(ERC721Enumerable) + override(ERC2981CollectionRoyalties, ERC721Enumerable) returns (bool) { - return interfaceId == INTERFACE_ID_ERC2981 || super.supportsInterface(interfaceId); + return + ERC2981CollectionRoyalties.supportsInterface(interfaceId) || + ERC721Enumerable.supportsInterface(interfaceId); + } + + function _getReceiver(uint256 tokenId) internal view override returns (address) { + return IERC721(HUB).ownerOf(_profileId); + } + + function _beforeRoyaltiesSet(uint256 royaltiesInBasisPoints) internal view override { + if (IERC721(HUB).ownerOf(_profileId) != msg.sender) { + revert Errors.NotProfileOwner(); + } + } + + function _getRoyaltiesInBasisPointsSlot() internal pure override returns (uint256) { + uint256 slot; + assembly { + slot := _royaltiesInBasisPoints.slot + } + return slot; } /** diff --git a/contracts/core/FollowNFT.sol b/contracts/core/FollowNFT.sol index e9d1d1a..3bd643a 100644 --- a/contracts/core/FollowNFT.sol +++ b/contracts/core/FollowNFT.sol @@ -1,52 +1,39 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {IFollowNFT} from '../interfaces/IFollowNFT.sol'; -import {IFollowModule} from '../interfaces/IFollowModule.sol'; -import {ILensHub} from '../interfaces/ILensHub.sol'; +import '../libraries/Constants.sol'; +import {DataTypes} from '../libraries/DataTypes.sol'; +import {ERC2981CollectionRoyalties} from './base/ERC2981CollectionRoyalties.sol'; +import {ERC721Enumerable} from './base/ERC721Enumerable.sol'; import {Errors} from '../libraries/Errors.sol'; import {Events} from '../libraries/Events.sol'; -import {DataTypes} from '../libraries/DataTypes.sol'; -import {Constants} from '../libraries/Constants.sol'; +import {HubRestricted} from './base/HubRestricted.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; +import {IERC721Time} from '../interfaces/IERC721Time.sol'; +import {IFollowNFT} from '../interfaces/IFollowNFT.sol'; +import {ILensHub} from '../interfaces/ILensHub.sol'; import {LensNFTBase} from './base/LensNFTBase.sol'; +import {MetaTxHelpers} from '../libraries/helpers/MetaTxHelpers.sol'; +import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; -/** - * @title FollowNFT - * @author Lens Protocol - * - * @notice This contract is the NFT that is minted upon following a given profile. It is cloned upon first follow for a - * given profile, and includes built-in governance power and delegation mechanisms. - * - * NOTE: This contract assumes total NFT supply for this follow NFT will never exceed 2^128 - 1 - */ -contract FollowNFT is LensNFTBase, IFollowNFT { - struct Snapshot { - uint128 blockNumber; - uint128 value; - } +contract FollowNFT is HubRestricted, LensNFTBase, ERC2981CollectionRoyalties, IFollowNFT { + using Strings for uint256; - address public immutable HUB; - - bytes32 internal constant DELEGATE_BY_SIG_TYPEHASH = - keccak256( - 'DelegateBySig(address delegator,address delegatee,uint256 nonce,uint256 deadline)' - ); - - mapping(address => mapping(uint256 => Snapshot)) internal _snapshots; - mapping(address => address) internal _delegates; - mapping(address => uint256) internal _snapshotCount; - mapping(uint256 => Snapshot) internal _delSupplySnapshots; - uint256 internal _delSupplySnapshotCount; - uint256 internal _profileId; - uint256 internal _tokenIdCounter; + uint256[5] ___DEPRECATED_SLOTS; // Deprecated slots, previously used for delegations. + uint256 internal _followedProfileId; + uint256 internal _lastFollowTokenId; bool private _initialized; - // We create the FollowNFT with the pre-computed HUB address before deploying the hub. - constructor(address hub) { - if (hub == address(0)) revert Errors.InitParamsInvalid(); - HUB = hub; + mapping(uint256 => FollowData) internal _followDataByFollowTokenId; + mapping(uint256 => uint256) internal _followTokenIdByFollowerProfileId; + mapping(uint256 => uint256) internal _followApprovalByFollowTokenId; + uint256 internal _royaltiesInBasisPoints; + + event FollowApproval(uint256 indexed followerProfileId, uint256 indexed followTokenId); + + constructor(address hub) HubRestricted(hub) { _initialized = true; } @@ -54,244 +41,430 @@ contract FollowNFT is LensNFTBase, IFollowNFT { function initialize(uint256 profileId) external override { if (_initialized) revert Errors.Initialized(); _initialized = true; - _profileId = profileId; + _followedProfileId = profileId; + _setRoyalty(1000); // 10% of royalties emit Events.FollowNFTInitialized(profileId, block.timestamp); } /// @inheritdoc IFollowNFT - function mint(address to) external override returns (uint256) { - if (msg.sender != HUB) revert Errors.NotHub(); - unchecked { - uint256 tokenId = ++_tokenIdCounter; - _mint(to, tokenId); - return tokenId; + function follow( + uint256 followerProfileId, + address executor, + uint256 followTokenId + ) external override onlyHub returns (uint256) { + if (_followTokenIdByFollowerProfileId[followerProfileId] != 0) { + revert AlreadyFollowing(); + } + + if (followTokenId == 0) { + // Fresh follow. + return _followMintingNewToken(followerProfileId); + } + + address followTokenOwner = _unsafeOwnerOf(followTokenId); + if (followTokenOwner != address(0)) { + // Provided follow token is wrapped. + return + _followWithWrappedToken({ + followerProfileId: followerProfileId, + executor: executor, + followTokenId: followTokenId, + followTokenOwner: followTokenOwner + }); + } + + uint256 currentFollowerProfileId = _followDataByFollowTokenId[followTokenId] + .followerProfileId; + if (currentFollowerProfileId != 0) { + // Provided follow token is unwrapped. + // It has a follower profile set already, it can only be used to follow if that profile was burnt. + return + _followWithUnwrappedTokenFromBurnedProfile({ + followerProfileId: followerProfileId, + followTokenId: followTokenId, + currentFollowerProfileId: currentFollowerProfileId + }); + } + + // Provided follow token does not exist anymore, it can only be used if profile attempting to follow is + // allowed to recover it. + return + _followByRecoveringToken({ + followerProfileId: followerProfileId, + followTokenId: followTokenId + }); + } + + /// @inheritdoc IFollowNFT + function unfollow(uint256 unfollowerProfileId, address executor) external override onlyHub { + uint256 followTokenId = _followTokenIdByFollowerProfileId[unfollowerProfileId]; + if (followTokenId == 0) { + revert NotFollowing(); + } + address followTokenOwner = _unsafeOwnerOf(followTokenId); + if (followTokenOwner == address(0)) { + // Follow token is unwrapped. + // Unfollowing and allowing recovery. + _unfollow({unfollower: unfollowerProfileId, followTokenId: followTokenId}); + _followDataByFollowTokenId[followTokenId] + .profileIdAllowedToRecover = unfollowerProfileId; + } else { + // Follow token is wrapped. + address unfollowerProfileOwner = IERC721(HUB).ownerOf(unfollowerProfileId); + // Follower profile owner or its approved delegated executor must hold the token or be approved-for-all. + if ( + (followTokenOwner != unfollowerProfileOwner) && + (followTokenOwner != executor) && + !isApprovedForAll(followTokenOwner, executor) && + !isApprovedForAll(followTokenOwner, unfollowerProfileOwner) + ) { + revert DoesNotHavePermissions(); + } + _unfollow({unfollower: unfollowerProfileId, followTokenId: followTokenId}); } } /// @inheritdoc IFollowNFT - function delegate(address delegatee) external override { - _delegate(msg.sender, delegatee); - } - - /// @inheritdoc IFollowNFT - function delegateBySig( - address delegator, - address delegatee, - DataTypes.EIP712Signature calldata sig - ) external override { - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - DELEGATE_BY_SIG_TYPEHASH, - delegator, - delegatee, - sigNonces[delegator]++, - sig.deadline - ) - ) - ), - delegator, - sig - ); + function removeFollower(uint256 followTokenId) external override { + address followTokenOwner = ownerOf(followTokenId); + if (followTokenOwner == msg.sender || isApprovedForAll(followTokenOwner, msg.sender)) { + _unfollowIfHasFollower(followTokenId); + } else { + revert DoesNotHavePermissions(); } - _delegate(delegator, delegatee); } /// @inheritdoc IFollowNFT - function getPowerByBlockNumber(address user, uint256 blockNumber) + function approveFollow(uint256 followerProfileId, uint256 followTokenId) external override { + if (!IERC721Time(HUB).exists(followerProfileId)) { + revert Errors.TokenDoesNotExist(); + } + address followTokenOwner = _unsafeOwnerOf(followTokenId); + if (followTokenOwner == address(0)) { + revert OnlyWrappedFollowTokens(); + } + if (followTokenOwner != msg.sender && !isApprovedForAll(followTokenOwner, msg.sender)) { + revert DoesNotHavePermissions(); + } + _approveFollow(followerProfileId, followTokenId); + } + + /// @inheritdoc IFollowNFT + function wrap(uint256 followTokenId) external override { + if (_isFollowTokenWrapped(followTokenId)) { + revert AlreadyWrapped(); + } + uint256 followerProfileId = _followDataByFollowTokenId[followTokenId].followerProfileId; + address wrappedTokenReceiver; + if (followerProfileId == 0) { + uint256 profileIdAllowedToRecover = _followDataByFollowTokenId[followTokenId] + .profileIdAllowedToRecover; + if (profileIdAllowedToRecover == 0) { + revert FollowTokenDoesNotExist(); + } + wrappedTokenReceiver = IERC721(HUB).ownerOf(profileIdAllowedToRecover); + delete _followDataByFollowTokenId[followTokenId].profileIdAllowedToRecover; + } else { + wrappedTokenReceiver = IERC721(HUB).ownerOf(followerProfileId); + } + if (msg.sender != wrappedTokenReceiver) { + revert DoesNotHavePermissions(); + } + _mint(wrappedTokenReceiver, followTokenId); + } + + /// @inheritdoc IFollowNFT + function unwrap(uint256 followTokenId) external override { + if (_followDataByFollowTokenId[followTokenId].followerProfileId == 0) { + revert NotFollowing(); + } + super.burn(followTokenId); + } + + /// @inheritdoc IFollowNFT + function processBlock(uint256 followerProfileId) external override onlyHub { + uint256 followTokenId = _followTokenIdByFollowerProfileId[followerProfileId]; + if (followTokenId != 0) { + if (!_isFollowTokenWrapped(followTokenId)) { + // Wrap it first, so the user stops following but does not lose the token when being blocked. + _mint(IERC721(HUB).ownerOf(followerProfileId), followTokenId); + } + _unfollow(followerProfileId, followTokenId); + ILensHub(HUB).emitUnfollowedEvent(followerProfileId, _followedProfileId); + } + } + + /// @inheritdoc IFollowNFT + function getFollowerProfileId(uint256 followTokenId) external view override returns (uint256) { + return _followDataByFollowTokenId[followTokenId].followerProfileId; + } + + /// @inheritdoc IFollowNFT + function isFollowing(uint256 followerProfileId) external view override returns (bool) { + return _followTokenIdByFollowerProfileId[followerProfileId] != 0; + } + + /// @inheritdoc IFollowNFT + function getFollowTokenId(uint256 followerProfileId) external view override returns (uint256) { + return _followTokenIdByFollowerProfileId[followerProfileId]; + } + + /// @inheritdoc IFollowNFT + function getOriginalFollowTimestamp(uint256 followTokenId) external view override returns (uint256) { - if (blockNumber > block.number) revert Errors.BlockNumberInvalid(); - uint256 snapshotCount = _snapshotCount[user]; - if (snapshotCount == 0) return 0; // Returning zero since this means the user never delegated and has no power - return _getSnapshotValueByBlockNumber(_snapshots[user], blockNumber, snapshotCount); + return _followDataByFollowTokenId[followTokenId].originalFollowTimestamp; } /// @inheritdoc IFollowNFT - function getDelegatedSupplyByBlockNumber(uint256 blockNumber) + function getFollowTimestamp(uint256 followTokenId) external view override returns (uint256) { + return _followDataByFollowTokenId[followTokenId].followTimestamp; + } + + /// @inheritdoc IFollowNFT + function getProfileIdAllowedToRecover(uint256 followTokenId) external view override returns (uint256) { - if (blockNumber > block.number) revert Errors.BlockNumberInvalid(); - uint256 snapshotCount = _delSupplySnapshotCount; - if (snapshotCount == 0) return 0; // Returning zero since this means a delegation has never occurred - return _getSnapshotValueByBlockNumber(_delSupplySnapshots, blockNumber, snapshotCount); + return _followDataByFollowTokenId[followTokenId].profileIdAllowedToRecover; + } + + /// @inheritdoc IFollowNFT + function getFollowData(uint256 followTokenId) + external + view + override + returns (FollowData memory) + { + return _followDataByFollowTokenId[followTokenId]; + } + + /// @inheritdoc IFollowNFT + function getFollowApproved(uint256 followTokenId) external view override returns (uint256) { + return _followApprovalByFollowTokenId[followTokenId]; + } + + function burnWithSig(uint256 followTokenId, DataTypes.EIP712Signature calldata sig) + public + override + { + _unfollowIfHasFollower(followTokenId); + super.burnWithSig(followTokenId, sig); + } + + function burn(uint256 followTokenId) public override { + _unfollowIfHasFollower(followTokenId); + super.burn(followTokenId); + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) + public + view + virtual + override(ERC2981CollectionRoyalties, ERC721Enumerable) + returns (bool) + { + return + ERC2981CollectionRoyalties.supportsInterface(interfaceId) || + ERC721Enumerable.supportsInterface(interfaceId); } function name() public view override returns (string memory) { - string memory handle = ILensHub(HUB).getHandle(_profileId); - return string(abi.encodePacked(handle, Constants.FOLLOW_NFT_NAME_SUFFIX)); + return string(abi.encodePacked(_followedProfileId.toString(), FOLLOW_NFT_NAME_SUFFIX)); } function symbol() public view override returns (string memory) { - string memory handle = ILensHub(HUB).getHandle(_profileId); - bytes4 firstBytes = bytes4(bytes(handle)); - return string(abi.encodePacked(firstBytes, Constants.FOLLOW_NFT_SYMBOL_SUFFIX)); - } - - function _getSnapshotValueByBlockNumber( - mapping(uint256 => Snapshot) storage _shots, - uint256 blockNumber, - uint256 snapshotCount - ) internal view returns (uint256) { - unchecked { - uint256 lower = 0; - uint256 upper = snapshotCount - 1; - - // First check most recent snapshot - if (_shots[upper].blockNumber <= blockNumber) return _shots[upper].value; - - // Next check implicit zero balance - if (_shots[lower].blockNumber > blockNumber) return 0; - - while (upper > lower) { - uint256 center = upper - (upper - lower) / 2; - Snapshot memory snapshot = _shots[center]; - if (snapshot.blockNumber == blockNumber) { - return snapshot.value; - } else if (snapshot.blockNumber < blockNumber) { - lower = center; - } else { - upper = center - 1; - } - } - return _shots[lower].value; - } + return string(abi.encodePacked(_followedProfileId.toString(), FOLLOW_NFT_SYMBOL_SUFFIX)); } /** * @dev This returns the follow NFT URI fetched from the hub. */ - function tokenURI(uint256 tokenId) public view override returns (string memory) { - if (!_exists(tokenId)) revert Errors.TokenDoesNotExist(); - return ILensHub(HUB).getFollowNFTURI(_profileId); + function tokenURI(uint256 followTokenId) public view override returns (string memory) { + if (!_exists(followTokenId)) revert Errors.TokenDoesNotExist(); + return ILensHub(HUB).getFollowNFTURI(_followedProfileId); + } + + function _followMintingNewToken(uint256 followerProfileId) internal returns (uint256) { + uint256 followTokenIdAssigned; + unchecked { + followTokenIdAssigned = ++_lastFollowTokenId; + } + _baseFollow({ + followerProfileId: followerProfileId, + followTokenId: followTokenIdAssigned, + isOriginalFollow: true + }); + return followTokenIdAssigned; + } + + function _followWithWrappedToken( + uint256 followerProfileId, + address executor, + uint256 followTokenId, + address followTokenOwner + ) internal returns (uint256) { + bool isFollowApproved = _followApprovalByFollowTokenId[followTokenId] == followerProfileId; + address followerProfileOwner = IERC721(HUB).ownerOf(followerProfileId); + if ( + !isFollowApproved && + followTokenOwner != followerProfileOwner && + followTokenOwner != executor && + !isApprovedForAll(followTokenOwner, executor) && + !isApprovedForAll(followTokenOwner, followerProfileOwner) + ) { + revert DoesNotHavePermissions(); + } + // The executor is allowed to write the follower in that wrapped token. + if (isFollowApproved) { + // The `_followApprovalByFollowTokenId` was used, now needs to be cleared. + _approveFollow(0, followTokenId); + } + _replaceFollower({ + currentFollowerProfileId: _followDataByFollowTokenId[followTokenId].followerProfileId, + newFollowerProfileId: followerProfileId, + followTokenId: followTokenId + }); + return followTokenId; + } + + function _followWithUnwrappedTokenFromBurnedProfile( + uint256 followerProfileId, + uint256 followTokenId, + uint256 currentFollowerProfileId + ) internal returns (uint256) { + if (IERC721Time(HUB).exists(currentFollowerProfileId)) { + revert DoesNotHavePermissions(); + } + _replaceFollower({ + currentFollowerProfileId: currentFollowerProfileId, + newFollowerProfileId: followerProfileId, + followTokenId: followTokenId + }); + return followTokenId; + } + + function _followByRecoveringToken(uint256 followerProfileId, uint256 followTokenId) + internal + returns (uint256) + { + if ( + _followDataByFollowTokenId[followTokenId].profileIdAllowedToRecover != followerProfileId + ) { + revert FollowTokenDoesNotExist(); + } + _baseFollow({ + followerProfileId: followerProfileId, + followTokenId: followTokenId, + isOriginalFollow: false + }); + return followTokenId; + } + + function _replaceFollower( + uint256 currentFollowerProfileId, + uint256 newFollowerProfileId, + uint256 followTokenId + ) internal { + if (currentFollowerProfileId != 0) { + // As it has a follower, unfollow first, removing current follower. + delete _followTokenIdByFollowerProfileId[currentFollowerProfileId]; + ILensHub(HUB).emitUnfollowedEvent(currentFollowerProfileId, _followedProfileId); + } + // Perform the follow, setting new follower. + _baseFollow({ + followerProfileId: newFollowerProfileId, + followTokenId: followTokenId, + isOriginalFollow: false + }); + } + + function _baseFollow( + uint256 followerProfileId, + uint256 followTokenId, + bool isOriginalFollow + ) internal { + _followTokenIdByFollowerProfileId[followerProfileId] = followTokenId; + _followDataByFollowTokenId[followTokenId].followerProfileId = uint160(followerProfileId); + _followDataByFollowTokenId[followTokenId].followTimestamp = uint48(block.timestamp); + delete _followDataByFollowTokenId[followTokenId].profileIdAllowedToRecover; + if (isOriginalFollow) { + _followDataByFollowTokenId[followTokenId].originalFollowTimestamp = uint48( + block.timestamp + ); + } + } + + function _unfollowIfHasFollower(uint256 followTokenId) internal { + uint256 followerProfileId = _followDataByFollowTokenId[followTokenId].followerProfileId; + if (followerProfileId != 0) { + _unfollow(followerProfileId, followTokenId); + ILensHub(HUB).emitUnfollowedEvent(followerProfileId, _followedProfileId); + } + } + + function _unfollow(uint256 unfollower, uint256 followTokenId) internal { + delete _followTokenIdByFollowerProfileId[unfollower]; + delete _followDataByFollowTokenId[followTokenId].followerProfileId; + delete _followDataByFollowTokenId[followTokenId].followTimestamp; + delete _followDataByFollowTokenId[followTokenId].profileIdAllowedToRecover; + } + + function _approveFollow(uint256 approvedProfileId, uint256 followTokenId) internal { + _followApprovalByFollowTokenId[followTokenId] = approvedProfileId; + emit FollowApproval(approvedProfileId, followTokenId); } /** - * @dev Upon transfers, we move the appropriate delegations, and emit the transfer event in the hub. + * @dev Upon transfers, we clear follow approvals, and emit the transfer event in the hub. */ function _beforeTokenTransfer( address from, address to, - uint256 tokenId + uint256 followTokenId ) internal override { - address fromDelegatee = _delegates[from]; - address toDelegatee = _delegates[to]; - address followModule = ILensHub(HUB).getFollowModule(_profileId); + if (from != address(0)) { + // It is cleared on unwrappings and transfers, and it can not be set on unwrapped tokens. + // As a consequence, there is no need to clear it on wrappings. + _approveFollow(0, followTokenId); + } + super._beforeTokenTransfer(from, to, followTokenId); + ILensHub(HUB).emitFollowNFTTransferEvent(_followedProfileId, followTokenId, from, to); + } - _moveDelegate(fromDelegatee, toDelegatee, 1); + function _getReceiver(uint256 followTokenId) internal view override returns (address) { + return IERC721(HUB).ownerOf(_followedProfileId); + } - super._beforeTokenTransfer(from, to, tokenId); - ILensHub(HUB).emitFollowNFTTransferEvent(_profileId, tokenId, from, to); - if (followModule != address(0)) { - IFollowModule(followModule).followModuleTransferHook(_profileId, from, to, tokenId); + function _beforeRoyaltiesSet(uint256 royaltiesInBasisPoints) internal view override { + if (IERC721(HUB).ownerOf(_followedProfileId) != msg.sender) { + revert Errors.NotProfileOwner(); } } - function _delegate(address delegator, address delegatee) internal { - uint256 delegatorBalance = balanceOf(delegator); - address previousDelegate = _delegates[delegator]; - _delegates[delegator] = delegatee; - _moveDelegate(previousDelegate, delegatee, delegatorBalance); + function _isFollowTokenWrapped(uint256 followTokenId) internal view returns (bool) { + return _exists(followTokenId); } - function _moveDelegate( - address from, - address to, - uint256 amount - ) internal { - unchecked { - bool fromZero = from == address(0); - if (!fromZero) { - uint256 fromSnapshotCount = _snapshotCount[from]; - - // Underflow is impossible since, if from != address(0), then a delegation must have occurred (at least 1 snapshot) - uint256 previous = _snapshots[from][fromSnapshotCount - 1].value; - uint128 newValue = uint128(previous - amount); - - _writeSnapshot(from, newValue, fromSnapshotCount); - emit Events.FollowNFTDelegatedPowerChanged(from, newValue, block.timestamp); - } - - if (to != address(0)) { - // if from == address(0) then this is an initial delegation (add amount to supply) - if (fromZero) { - // It is expected behavior that the `previousDelSupply` underflows upon the first delegation, - // returning the expected value of zero - uint256 delSupplySnapshotCount = _delSupplySnapshotCount; - uint128 previousDelSupply = _delSupplySnapshots[delSupplySnapshotCount - 1] - .value; - uint128 newDelSupply = uint128(previousDelSupply + amount); - _writeSupplySnapshot(newDelSupply, delSupplySnapshotCount); - } - - // It is expected behavior that `previous` underflows upon the first delegation to an address, - // returning the expected value of zero - uint256 toSnapshotCount = _snapshotCount[to]; - uint128 previous = _snapshots[to][toSnapshotCount - 1].value; - uint128 newValue = uint128(previous + amount); - _writeSnapshot(to, newValue, toSnapshotCount); - emit Events.FollowNFTDelegatedPowerChanged(to, newValue, block.timestamp); - } else { - // If from != address(0) then this is removing a delegation, otherwise we're dealing with a - // non-delegated burn of tokens and don't need to take any action - if (!fromZero) { - // Upon removing delegation (from != address(0) && to == address(0)), supply calculations cannot - // underflow because if from != address(0), then a delegation must have previously occurred, so - // the snapshot count must be >= 1 and the previous delegated supply must be >= amount - uint256 delSupplySnapshotCount = _delSupplySnapshotCount; - uint128 previousDelSupply = _delSupplySnapshots[delSupplySnapshotCount - 1] - .value; - uint128 newDelSupply = uint128(previousDelSupply - amount); - _writeSupplySnapshot(newDelSupply, delSupplySnapshotCount); - } - } - } + function _followTokenExists(uint256 followTokenId) internal view returns (bool) { + return + _followDataByFollowTokenId[followTokenId].followerProfileId != 0 || + _isFollowTokenWrapped(followTokenId); } - function _writeSnapshot( - address owner, - uint128 newValue, - uint256 ownerSnapshotCount - ) internal { - unchecked { - uint128 currentBlock = uint128(block.number); - mapping(uint256 => Snapshot) storage ownerSnapshots = _snapshots[owner]; - - // Doing multiple operations in the same block - if ( - ownerSnapshotCount != 0 && - ownerSnapshots[ownerSnapshotCount - 1].blockNumber == currentBlock - ) { - ownerSnapshots[ownerSnapshotCount - 1].value = newValue; - } else { - ownerSnapshots[ownerSnapshotCount] = Snapshot(currentBlock, newValue); - _snapshotCount[owner] = ownerSnapshotCount + 1; - } - } - } - - function _writeSupplySnapshot(uint128 newValue, uint256 supplySnapshotCount) internal { - unchecked { - uint128 currentBlock = uint128(block.number); - - // Doing multiple operations in the same block - if ( - supplySnapshotCount != 0 && - _delSupplySnapshots[supplySnapshotCount - 1].blockNumber == currentBlock - ) { - _delSupplySnapshots[supplySnapshotCount - 1].value = newValue; - } else { - _delSupplySnapshots[supplySnapshotCount] = Snapshot(currentBlock, newValue); - _delSupplySnapshotCount = supplySnapshotCount + 1; - } + function _getRoyaltiesInBasisPointsSlot() internal pure override returns (uint256) { + uint256 slot; + assembly { + slot := _royaltiesInBasisPoints.slot } + return slot; } } diff --git a/contracts/core/LensHub.sol b/contracts/core/LensHub.sol index 9b57ea4..530688b 100644 --- a/contracts/core/LensHub.sol +++ b/contracts/core/LensHub.sol @@ -1,16 +1,20 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; +import {IFollowNFT} from '../interfaces/IFollowNFT.sol'; +import {ILensNFTBase} from '../interfaces/ILensNFTBase.sol'; import {ILensHub} from '../interfaces/ILensHub.sol'; + import {Events} from '../libraries/Events.sol'; -import {Helpers} from '../libraries/Helpers.sol'; -import {Constants} from '../libraries/Constants.sol'; import {DataTypes} from '../libraries/DataTypes.sol'; import {Errors} from '../libraries/Errors.sol'; -import {PublishingLogic} from '../libraries/PublishingLogic.sol'; +import {GeneralLib} from '../libraries/GeneralLib.sol'; +import {ProfileLib} from '../libraries/ProfileLib.sol'; +import {PublishingLib} from '../libraries/PublishingLib.sol'; import {ProfileTokenURILogic} from '../libraries/ProfileTokenURILogic.sol'; -import {InteractionLogic} from '../libraries/InteractionLogic.sol'; +import '../libraries/Constants.sol'; + import {LensNFTBase} from './base/LensNFTBase.sol'; import {LensMultiState} from './base/LensMultiState.sol'; import {LensHubStorage} from './storage/LensHubStorage.sol'; @@ -63,7 +67,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub address newGovernance ) external override initializer { super._initialize(name, symbol); - _setState(DataTypes.ProtocolState.Paused); + GeneralLib.initState(DataTypes.ProtocolState.Paused); _setGovernance(newGovernance); } @@ -78,26 +82,12 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub /// @inheritdoc ILensHub function setEmergencyAdmin(address newEmergencyAdmin) external override onlyGov { - address prevEmergencyAdmin = _emergencyAdmin; - _emergencyAdmin = newEmergencyAdmin; - emit Events.EmergencyAdminSet( - msg.sender, - prevEmergencyAdmin, - newEmergencyAdmin, - block.timestamp - ); + GeneralLib.setEmergencyAdmin(newEmergencyAdmin); } /// @inheritdoc ILensHub function setState(DataTypes.ProtocolState newState) external override { - if (msg.sender == _emergencyAdmin) { - if (newState == DataTypes.ProtocolState.Unpaused) - revert Errors.EmergencyAdminCannotUnpause(); - _validateNotPaused(); - } else if (msg.sender != _governance) { - revert Errors.NotGovernanceOrEmergencyAdmin(); - } - _setState(newState); + GeneralLib.setState(newState); } ///@inheritdoc ILensHub @@ -140,6 +130,25 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub /// *****PROFILE OWNER FUNCTIONS***** /// ********************************* + /// @inheritdoc ILensNFTBase + function permit( + address spender, + uint256 tokenId, + DataTypes.EIP712Signature calldata sig + ) external override { + GeneralLib.permit(spender, tokenId, sig); + } + + /// @inheritdoc ILensNFTBase + function permitForAll( + address owner, + address operator, + bool approved, + DataTypes.EIP712Signature calldata sig + ) external override { + GeneralLib.permitForAll(owner, operator, approved, sig); + } + /// @inheritdoc ILensHub function createProfile(DataTypes.CreateProfileData calldata vars) external @@ -147,24 +156,21 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenNotPaused returns (uint256) { - if (!_profileCreatorWhitelisted[msg.sender]) revert Errors.ProfileCreatorNotWhitelisted(); unchecked { uint256 profileId = ++_profileCounter; _mint(vars.to, profileId); - PublishingLogic.createProfile( - vars, - profileId, - _profileIdByHandleHash, - _profileById, - _followModuleWhitelisted - ); + ProfileLib.createProfile(vars, profileId); return profileId; } } /// @inheritdoc ILensHub - function setDefaultProfile(uint256 profileId) external override whenNotPaused { - _setDefaultProfile(msg.sender, profileId); + function setDefaultProfile(address onBehalfOf, uint256 profileId) + external + override + whenNotPaused + { + GeneralLib.setDefaultProfile(onBehalfOf, profileId); } /// @inheritdoc ILensHub @@ -173,24 +179,25 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH, - vars.wallet, - vars.profileId, - sigNonces[vars.wallet]++, - vars.sig.deadline - ) - ) - ), - vars.wallet, - vars.sig - ); - _setDefaultProfile(vars.wallet, vars.profileId); - } + GeneralLib.setDefaultProfileWithSig(vars); + } + + /// @inheritdoc ILensHub + function setProfileMetadataURI(uint256 profileId, string calldata metadataURI) + external + override + whenNotPaused + { + ProfileLib.setProfileMetadataURI(profileId, metadataURI); + } + + /// @inheritdoc ILensHub + function setProfileMetadataURIWithSig(DataTypes.SetProfileMetadataURIWithSigData calldata vars) + external + override + whenNotPaused + { + ProfileLib.setProfileMetadataURIWithSig(vars); } /// @inheritdoc ILensHub @@ -199,14 +206,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub address followModule, bytes calldata followModuleInitData ) external override whenNotPaused { - _validateCallerIsProfileOwner(profileId); - PublishingLogic.setFollowModule( - profileId, - followModule, - followModuleInitData, - _profileById[profileId], - _followModuleWhitelisted - ); + ProfileLib.setFollowModule(profileId, followModule, followModuleInitData); } /// @inheritdoc ILensHub @@ -215,32 +215,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH, - vars.profileId, - vars.followModule, - keccak256(vars.followModuleInitData), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - PublishingLogic.setFollowModule( - vars.profileId, - vars.followModule, - vars.followModuleInitData, - _profileById[vars.profileId], - _followModuleWhitelisted - ); + ProfileLib.setFollowModuleWithSig(vars); } /// @inheritdoc ILensHub @@ -255,25 +230,23 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_DISPATCHER_WITH_SIG_TYPEHASH, - vars.profileId, - vars.dispatcher, - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - _setDispatcher(vars.profileId, vars.dispatcher); + ProfileLib.setDispatcherWithSig(vars); + } + + /// @inheritdoc ILensHub + function setDelegatedExecutorApproval(address executor, bool approved) + external + override + whenNotPaused + { + GeneralLib.setDelegatedExecutorApproval(executor, approved); + } + + /// @inheritdoc ILensHub + function setDelegatedExecutorApprovalWithSig( + DataTypes.SetDelegatedExecutorApprovalWithSigData calldata vars + ) external override whenNotPaused { + GeneralLib.setDelegatedExecutorApprovalWithSig(vars); } /// @inheritdoc ILensHub @@ -282,8 +255,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - _validateCallerIsProfileOwnerOrDispatcher(profileId); - _setProfileImageURI(profileId, imageURI); + ProfileLib.setProfileImageURI(profileId, imageURI); } /// @inheritdoc ILensHub @@ -292,25 +264,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH, - vars.profileId, - keccak256(bytes(vars.imageURI)), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - _setProfileImageURI(vars.profileId, vars.imageURI); + ProfileLib.setProfileImageURIWithSig(vars); } /// @inheritdoc ILensHub @@ -319,8 +273,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - _validateCallerIsProfileOwnerOrDispatcher(profileId); - _setFollowNFTURI(profileId, followNFTURI); + ProfileLib.setFollowNFTURI(profileId, followNFTURI); } /// @inheritdoc ILensHub @@ -329,25 +282,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override whenNotPaused { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_FOLLOW_NFT_URI_WITH_SIG_TYPEHASH, - vars.profileId, - keccak256(bytes(vars.followNFTURI)), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - _setFollowNFTURI(vars.profileId, vars.followNFTURI); + ProfileLib.setFollowNFTURIWithSig(vars); } /// @inheritdoc ILensHub @@ -357,16 +292,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - _validateCallerIsProfileOwnerOrDispatcher(vars.profileId); - return - _createPost( - vars.profileId, - vars.contentURI, - vars.collectModule, - vars.collectModuleInitData, - vars.referenceModule, - vars.referenceModuleInitData - ); + return PublishingLib.post(vars); } /// @inheritdoc ILensHub @@ -376,37 +302,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - POST_WITH_SIG_TYPEHASH, - vars.profileId, - keccak256(bytes(vars.contentURI)), - vars.collectModule, - keccak256(vars.collectModuleInitData), - vars.referenceModule, - keccak256(vars.referenceModuleInitData), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - return - _createPost( - vars.profileId, - vars.contentURI, - vars.collectModule, - vars.collectModuleInitData, - vars.referenceModule, - vars.referenceModuleInitData - ); + return PublishingLib.postWithSig(vars); } /// @inheritdoc ILensHub @@ -416,8 +312,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - _validateCallerIsProfileOwnerOrDispatcher(vars.profileId); - return _createComment(vars); + return PublishingLib.comment(vars); } /// @inheritdoc ILensHub @@ -427,45 +322,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - COMMENT_WITH_SIG_TYPEHASH, - vars.profileId, - keccak256(bytes(vars.contentURI)), - vars.profileIdPointed, - vars.pubIdPointed, - keccak256(vars.referenceModuleData), - vars.collectModule, - keccak256(vars.collectModuleInitData), - vars.referenceModule, - keccak256(vars.referenceModuleInitData), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - return - _createComment( - DataTypes.CommentData( - vars.profileId, - vars.contentURI, - vars.profileIdPointed, - vars.pubIdPointed, - vars.referenceModuleData, - vars.collectModule, - vars.collectModuleInitData, - vars.referenceModule, - vars.referenceModuleInitData - ) - ); + return PublishingLib.commentWithSig(vars); } /// @inheritdoc ILensHub @@ -475,8 +332,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - _validateCallerIsProfileOwnerOrDispatcher(vars.profileId); - return _createMirror(vars); + return PublishingLib.mirror(vars); } /// @inheritdoc ILensHub @@ -486,67 +342,27 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenPublishingEnabled returns (uint256) { - address owner = ownerOf(vars.profileId); - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - MIRROR_WITH_SIG_TYPEHASH, - vars.profileId, - vars.profileIdPointed, - vars.pubIdPointed, - keccak256(vars.referenceModuleData), - vars.referenceModule, - keccak256(vars.referenceModuleInitData), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - return - _createMirror( - DataTypes.MirrorData( - vars.profileId, - vars.profileIdPointed, - vars.pubIdPointed, - vars.referenceModuleData, - vars.referenceModule, - vars.referenceModuleInitData - ) - ); + return PublishingLib.mirrorWithSig(vars); } /** - * @notice Burns a profile, this maintains the profile data struct, but deletes the - * handle hash to profile ID mapping value. - * - * NOTE: This overrides the LensNFTBase contract's `burn()` function and calls it to fully burn - * the NFT. + * @notice Burns a profile, this maintains the profile data struct. */ function burn(uint256 tokenId) public override whenNotPaused { - super.burn(tokenId); - _clearHandleHash(tokenId); + if (!_isApprovedOrOwner(msg.sender, tokenId)) revert Errors.NotOwnerOrApproved(); + _burn(tokenId); } /** - * @notice Burns a profile with a signature, this maintains the profile data struct, but deletes the - * handle hash to profile ID mapping value. - * - * NOTE: This overrides the LensNFTBase contract's `burnWithSig()` function and calls it to fully burn - * the NFT. + * @notice Burns a profile with a signature, this maintains the profile data struct. */ function burnWithSig(uint256 tokenId, DataTypes.EIP712Signature calldata sig) public override whenNotPaused { - super.burnWithSig(tokenId, sig); - _clearHandleHash(tokenId); + GeneralLib.baseBurnWithSig(tokenId, sig); + _burn(tokenId); } /// *************************************** @@ -554,20 +370,19 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub /// *************************************** /// @inheritdoc ILensHub - function follow(uint256[] calldata profileIds, bytes[] calldata datas) - external - override - whenNotPaused - returns (uint256[] memory) - { + function follow( + uint256 followerProfileId, + uint256[] calldata idsOfProfilesToFollow, + uint256[] calldata followTokenIds, + bytes[] calldata datas + ) external override whenNotPaused returns (uint256[] memory) { return - InteractionLogic.follow( - msg.sender, - profileIds, - datas, - _profileById, - _profileIdByHandleHash - ); + GeneralLib.follow({ + followerProfileId: followerProfileId, + idsOfProfilesToFollow: idsOfProfilesToFollow, + followTokenIds: followTokenIds, + followModuleDatas: datas + }); } /// @inheritdoc ILensHub @@ -577,57 +392,64 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenNotPaused returns (uint256[] memory) { - uint256 dataLength = vars.datas.length; - bytes32[] memory dataHashes = new bytes32[](dataLength); - for (uint256 i = 0; i < dataLength; ) { - dataHashes[i] = keccak256(vars.datas[i]); - unchecked { - ++i; - } - } - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - FOLLOW_WITH_SIG_TYPEHASH, - keccak256(abi.encodePacked(vars.profileIds)), - keccak256(abi.encodePacked(dataHashes)), - sigNonces[vars.follower]++, - vars.sig.deadline - ) - ) - ), - vars.follower, - vars.sig - ); - } + return GeneralLib.followWithSig(vars); + } + + /// @inheritdoc ILensHub + function unfollow(uint256 unfollowerProfileId, uint256[] calldata idsOfProfilesToUnfollow) + external + override + whenNotPaused + { return - InteractionLogic.follow( - vars.follower, - vars.profileIds, - vars.datas, - _profileById, - _profileIdByHandleHash - ); + GeneralLib.unfollow({ + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: idsOfProfilesToUnfollow + }); + } + + /// @inheritdoc ILensHub + function unfollowWithSig(DataTypes.UnfollowWithSigData calldata vars) + external + override + whenNotPaused + { + return GeneralLib.unfollowWithSig(vars); + } + + /// @inheritdoc ILensHub + function setBlockStatus( + uint256 byProfileId, + uint256[] calldata idsOfProfilesToSetBlockStatus, + bool[] calldata blockStatus + ) external override whenNotPaused { + return GeneralLib.setBlockStatus(byProfileId, idsOfProfilesToSetBlockStatus, blockStatus); + } + + /// @inheritdoc ILensHub + function setBlockStatusWithSig(DataTypes.SetBlockStatusWithSigData calldata vars) + external + override + whenNotPaused + { + return GeneralLib.setBlockStatusWithSig(vars); } /// @inheritdoc ILensHub function collect( - uint256 profileId, + uint256 collectorProfileId, + uint256 publisherProfileId, // TODO: Think if we can have better naming uint256 pubId, bytes calldata data ) external override whenNotPaused returns (uint256) { return - InteractionLogic.collect( - msg.sender, - profileId, - pubId, - data, - COLLECT_NFT_IMPL, - _pubByIdByProfile, - _profileById - ); + GeneralLib.collect({ + collectorProfileId: collectorProfileId, + publisherProfileId: publisherProfileId, + pubId: pubId, + collectModuleData: data, + collectNFTImpl: COLLECT_NFT_IMPL + }); } /// @inheritdoc ILensHub @@ -637,34 +459,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub whenNotPaused returns (uint256) { - unchecked { - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - COLLECT_WITH_SIG_TYPEHASH, - vars.profileId, - vars.pubId, - keccak256(vars.data), - sigNonces[vars.collector]++, - vars.sig.deadline - ) - ) - ), - vars.collector, - vars.sig - ); - } - return - InteractionLogic.collect( - vars.collector, - vars.profileId, - vars.pubId, - vars.data, - COLLECT_NFT_IMPL, - _pubByIdByProfile, - _profileById - ); + return GeneralLib.collectWithSig(vars, COLLECT_NFT_IMPL); } /// @inheritdoc ILensHub @@ -699,10 +494,31 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub ); } + /// @inheritdoc ILensHub + function emitUnfollowedEvent(uint256 unfollowerProfileId, uint256 idOfProfileUnfollowed) + external + override + { + address expectedFollowNFT = _profileById[idOfProfileUnfollowed].followNFT; + if (msg.sender != expectedFollowNFT) { + revert Errors.CallerNotFollowNFT(); + } + emit Events.Unfollowed(unfollowerProfileId, idOfProfileUnfollowed, block.timestamp); + } + /// ********************************* /// *****EXTERNAL VIEW FUNCTIONS***** /// ********************************* + function isFollowing(uint256 followerProfileId, uint256 followedProfileId) + external + view + returns (bool) + { + address followNFT = _profileById[followedProfileId].followNFT; + return followNFT != address(0) && IFollowNFT(followNFT).isFollowing(followerProfileId); + } + /// @inheritdoc ILensHub function isProfileCreatorWhitelisted(address profileCreator) external @@ -713,11 +529,6 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub return _profileCreatorWhitelisted[profileCreator]; } - /// @inheritdoc ILensHub - function defaultProfile(address wallet) external view override returns (uint256) { - return _defaultProfileByAddress[wallet]; - } - /// @inheritdoc ILensHub function isFollowModuleWhitelisted(address followModule) external view override returns (bool) { return _followModuleWhitelisted[followModule]; @@ -748,6 +559,35 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub return _governance; } + /// @inheritdoc ILensHub + function isDelegatedExecutorApproved(address wallet, address executor) + external + view + returns (bool) + { + return _delegatedExecutorApproval[wallet][executor]; + } + + /// @inheritdoc ILensHub + function isBlocked(uint256 profileId, uint256 byProfileId) external view returns (bool) { + return _blockedStatus[byProfileId][profileId]; + } + + /// @inheritdoc ILensHub + function getDefaultProfile(address wallet) external view override returns (uint256) { + return _defaultProfileByAddress[wallet]; + } + + /// @inheritdoc ILensHub + function getProfileMetadataURI(uint256 profileId) + external + view + override + returns (string memory) + { + return _metadataByProfile[profileId]; + } + /// @inheritdoc ILensHub function getDispatcher(uint256 profileId) external view override returns (address) { return _dispatcherByProfile[profileId]; @@ -758,6 +598,11 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub return _profileById[profileId].pubCount; } + /// @inheritdoc ILensHub + function getProfileImageURI(uint256 profileId) external view override returns (string memory) { + return _profileById[profileId].imageURI; + } + /// @inheritdoc ILensHub function getFollowNFT(uint256 profileId) external view override returns (address) { return _profileById[profileId].followNFT; @@ -803,11 +648,6 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub return _pubByIdByProfile[profileId][pubId].referenceModule; } - /// @inheritdoc ILensHub - function getHandle(uint256 profileId) external view override returns (string memory) { - return _profileById[profileId].handle; - } - /// @inheritdoc ILensHub function getPubPointer(uint256 profileId, uint256 pubId) external @@ -827,18 +667,7 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub override returns (string memory) { - (uint256 rootProfileId, uint256 rootPubId, ) = Helpers.getPointedIfMirror( - profileId, - pubId, - _pubByIdByProfile - ); - return _pubByIdByProfile[rootProfileId][rootPubId].contentURI; - } - - /// @inheritdoc ILensHub - function getProfileIdByHandle(string calldata handle) external view override returns (uint256) { - bytes32 handleHash = keccak256(bytes(handle)); - return _profileIdByHandleHash[handleHash]; + return GeneralLib.getContentURI(profileId, pubId); } /// @inheritdoc ILensHub @@ -879,21 +708,6 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub } } - /** - * @dev Overrides the ERC721 tokenURI function to return the associated URI with a given profile. - */ - function tokenURI(uint256 tokenId) public view override returns (string memory) { - address followNFT = _profileById[tokenId].followNFT; - return - ProfileTokenURILogic.getProfileTokenURI( - tokenId, - followNFT == address(0) ? 0 : IERC721Enumerable(followNFT).totalSupply(), - ownerOf(tokenId), - _profileById[tokenId].handle, - _profileById[tokenId].imageURI - ); - } - /// @inheritdoc ILensHub function getFollowNFTImpl() external view override returns (address) { return FOLLOW_NFT_IMPL; @@ -904,81 +718,34 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub return COLLECT_NFT_IMPL; } + /** + * @dev Overrides the LensNFTBase function to compute the domain separator in the GeneralLib. + */ + function getDomainSeparator() external view override returns (bytes32) { + return GeneralLib.getDomainSeparator(); + } + + /** + * @dev Overrides the ERC721 tokenURI function to return the associated URI with a given profile. + */ + function tokenURI(uint256 tokenId) public view override returns (string memory) { + address followNFT = _profileById[tokenId].followNFT; + return + ProfileTokenURILogic.getProfileTokenURI( + tokenId, + followNFT == address(0) ? 0 : IERC721Enumerable(followNFT).totalSupply(), + ownerOf(tokenId), + 'Lens Profile', + _profileById[tokenId].imageURI + ); + } + /// **************************** /// *****INTERNAL FUNCTIONS***** /// **************************** function _setGovernance(address newGovernance) internal { - address prevGovernance = _governance; - _governance = newGovernance; - emit Events.GovernanceSet(msg.sender, prevGovernance, newGovernance, block.timestamp); - } - - function _createPost( - uint256 profileId, - string memory contentURI, - address collectModule, - bytes memory collectModuleData, - address referenceModule, - bytes memory referenceModuleData - ) internal returns (uint256) { - unchecked { - uint256 pubId = ++_profileById[profileId].pubCount; - PublishingLogic.createPost( - profileId, - contentURI, - collectModule, - collectModuleData, - referenceModule, - referenceModuleData, - pubId, - _pubByIdByProfile, - _collectModuleWhitelisted, - _referenceModuleWhitelisted - ); - return pubId; - } - } - - /* - * If the profile ID is zero, this is the equivalent of "unsetting" a default profile. - * Note that the wallet address should either be the message sender or validated via a signature - * prior to this function call. - */ - function _setDefaultProfile(address wallet, uint256 profileId) internal { - if (profileId > 0 && wallet != ownerOf(profileId)) revert Errors.NotProfileOwner(); - - _defaultProfileByAddress[wallet] = profileId; - - emit Events.DefaultProfileSet(wallet, profileId, block.timestamp); - } - - function _createComment(DataTypes.CommentData memory vars) internal returns (uint256) { - unchecked { - uint256 pubId = ++_profileById[vars.profileId].pubCount; - PublishingLogic.createComment( - vars, - pubId, - _profileById, - _pubByIdByProfile, - _collectModuleWhitelisted, - _referenceModuleWhitelisted - ); - return pubId; - } - } - - function _createMirror(DataTypes.MirrorData memory vars) internal returns (uint256) { - unchecked { - uint256 pubId = ++_profileById[vars.profileId].pubCount; - PublishingLogic.createMirror( - vars, - pubId, - _pubByIdByProfile, - _referenceModuleWhitelisted - ); - return pubId; - } + GeneralLib.setGovernance(newGovernance); } function _setDispatcher(uint256 profileId, address dispatcher) internal { @@ -986,23 +753,6 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub emit Events.DispatcherSet(profileId, dispatcher, block.timestamp); } - function _setProfileImageURI(uint256 profileId, string calldata imageURI) internal { - if (bytes(imageURI).length > Constants.MAX_PROFILE_IMAGE_URI_LENGTH) - revert Errors.ProfileImageURILengthInvalid(); - _profileById[profileId].imageURI = imageURI; - emit Events.ProfileImageURISet(profileId, imageURI, block.timestamp); - } - - function _setFollowNFTURI(uint256 profileId, string calldata followNFTURI) internal { - _profileById[profileId].followNFTURI = followNFTURI; - emit Events.FollowNFTURISet(profileId, followNFTURI, block.timestamp); - } - - function _clearHandleHash(uint256 profileId) internal { - bytes32 handleHash = keccak256(bytes(_profileById[profileId].handle)); - _profileIdByHandleHash[handleHash] = 0; - } - function _beforeTokenTransfer( address from, address to, @@ -1019,13 +769,6 @@ contract LensHub is LensNFTBase, VersionedInitializable, LensMultiState, LensHub super._beforeTokenTransfer(from, to, tokenId); } - function _validateCallerIsProfileOwnerOrDispatcher(uint256 profileId) internal view { - if (msg.sender == ownerOf(profileId) || msg.sender == _dispatcherByProfile[profileId]) { - return; - } - revert Errors.NotProfileOwnerOrDispatcher(); - } - function _validateCallerIsProfileOwner(uint256 profileId) internal view { if (msg.sender != ownerOf(profileId)) revert Errors.NotProfileOwner(); } diff --git a/contracts/core/base/ERC2981CollectionRoyalties.sol b/contracts/core/base/ERC2981CollectionRoyalties.sol new file mode 100644 index 0000000..339cb76 --- /dev/null +++ b/contracts/core/base/ERC2981CollectionRoyalties.sol @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.0; + +import {Errors} from '../../libraries/Errors.sol'; +import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol'; +import {IERC2981} from '@openzeppelin/contracts/interfaces/IERC2981.sol'; + +abstract contract ERC2981CollectionRoyalties is IERC2981 { + uint16 internal constant BASIS_POINTS = 10000; + // bytes4(keccak256('royaltyInfo(uint256,uint256)')) == 0x2a55205a + bytes4 internal constant INTERFACE_ID_ERC2981 = 0x2a55205a; + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { + return interfaceId == INTERFACE_ID_ERC2981 || interfaceId == type(IERC165).interfaceId; + } + + /** + * @notice Changes the royalty percentage for secondary sales. + * + * @param royaltiesInBasisPoints The royalty percentage meassured in basis points. + */ + function setRoyalty(uint256 royaltiesInBasisPoints) external { + _beforeRoyaltiesSet(royaltiesInBasisPoints); + _setRoyalty(royaltiesInBasisPoints); + } + + /** + * @notice Called with the sale price to determine how much royalty is owed and to whom. + * + * @param tokenId The ID of the token queried for royalty information. + * @param salePrice The sale price of the token specified. + * @return A tuple with the address who should receive the royalties and the royalty + * payment amount for the given sale price. + */ + function royaltyInfo(uint256 tokenId, uint256 salePrice) + external + view + returns (address, uint256) + { + return (_getReceiver(tokenId), _getRoyaltyAmount(tokenId, salePrice)); + } + + function _setRoyalty(uint256 royaltiesInBasisPoints) internal virtual { + if (royaltiesInBasisPoints > BASIS_POINTS) { + revert Errors.InvalidParameter(); + } else { + _storeRoyaltiesInBasisPoints(royaltiesInBasisPoints); + } + } + + function _getRoyaltyAmount(uint256 tokenId, uint256 salePrice) + internal + view + virtual + returns (uint256) + { + return (salePrice * _loadRoyaltiesInBasisPoints()) / BASIS_POINTS; + } + + function _storeRoyaltiesInBasisPoints(uint256 royaltiesInBasisPoints) internal virtual { + uint256 royaltiesInBasisPointsSlot = _getRoyaltiesInBasisPointsSlot(); + assembly { + sstore(royaltiesInBasisPointsSlot, royaltiesInBasisPoints) + } + } + + function _loadRoyaltiesInBasisPoints() internal view virtual returns (uint256) { + uint256 royaltiesInBasisPointsSlot = _getRoyaltiesInBasisPointsSlot(); + uint256 royaltyAmount; + assembly { + royaltyAmount := sload(royaltiesInBasisPointsSlot) + } + return royaltyAmount; + } + + function _beforeRoyaltiesSet(uint256 royaltiesInBasisPoints) internal view virtual {} + + function _getRoyaltiesInBasisPointsSlot() internal view virtual returns (uint256); + + function _getReceiver(uint256 tokenId) internal view virtual returns (address); +} diff --git a/contracts/core/base/ERC721Enumerable.sol b/contracts/core/base/ERC721Enumerable.sol index 7ceb81a..e7917ff 100644 --- a/contracts/core/base/ERC721Enumerable.sol +++ b/contracts/core/base/ERC721Enumerable.sol @@ -2,8 +2,10 @@ pragma solidity ^0.8.0; -import './ERC721Time.sol'; -import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol'; +import {Errors} from '../../libraries/Errors.sol'; +import {ERC721Time} from './ERC721Time.sol'; +import {IERC721Enumerable} from '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol'; +import {IERC165} from '@openzeppelin/contracts/interfaces/IERC165.sol'; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds @@ -50,12 +52,15 @@ abstract contract ERC721Enumerable is ERC721Time, IERC721Enumerable { override returns (uint256) { - require(index < ERC721Time.balanceOf(owner), 'ERC721Enumerable: owner index out of bounds'); + if (index >= ERC721Time.balanceOf(owner)) + revert Errors.ERC721Enumerable_OwnerIndexOutOfBounds(); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. + * @dev TotalSupply is decreased when the Profile is burned. + * @dev If you're looking how to get the next ProfileId created - see _profileCounter */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; @@ -65,10 +70,8 @@ abstract contract ERC721Enumerable is ERC721Time, IERC721Enumerable { * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { - require( - index < ERC721Enumerable.totalSupply(), - 'ERC721Enumerable: global index out of bounds' - ); + if (index >= ERC721Enumerable.totalSupply()) + revert Errors.ERC721Enumerable_GlobalIndexOutOfBounds(); return _allTokens[index]; } diff --git a/contracts/core/base/ERC721Time.sol b/contracts/core/base/ERC721Time.sol index b3b3845..ec7b6d9 100644 --- a/contracts/core/base/ERC721Time.sol +++ b/contracts/core/base/ERC721Time.sol @@ -2,13 +2,16 @@ pragma solidity ^0.8.0; -import './IERC721Time.sol'; -import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol'; -import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol'; -import '@openzeppelin/contracts/utils/Address.sol'; -import '@openzeppelin/contracts/utils/Context.sol'; -import '@openzeppelin/contracts/utils/Strings.sol'; -import '@openzeppelin/contracts/utils/introspection/ERC165.sol'; +import {Errors} from '../../libraries/Errors.sol'; +import {IERC721Time} from '../../interfaces/IERC721Time.sol'; +import {IERC721Receiver} from '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol'; +import {IERC721Metadata} from '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol'; +import {Address} from '@openzeppelin/contracts/utils/Address.sol'; +import {Context} from '@openzeppelin/contracts/utils/Context.sol'; +import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; +import {ERC165} from '@openzeppelin/contracts/utils/introspection/ERC165.sol'; +import {IERC165} from '@openzeppelin/contracts/interfaces/IERC165.sol'; +import {IERC721} from '@openzeppelin/contracts/interfaces/IERC721.sol'; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including @@ -74,7 +77,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { - require(owner != address(0), 'ERC721: balance query for the zero address'); + if (owner == address(0)) revert Errors.ERC721Time_BalanceQueryForZeroAddress(); return _balances[owner]; } @@ -83,7 +86,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _tokenData[tokenId].owner; - require(owner != address(0), 'ERC721: owner query for nonexistent token'); + if (owner == address(0)) revert Errors.ERC721Time_OwnerQueryForNonexistantToken(); return owner; } @@ -92,12 +95,12 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { */ function mintTimestampOf(uint256 tokenId) public view virtual override returns (uint256) { uint96 mintTimestamp = _tokenData[tokenId].mintTimestamp; - require(mintTimestamp != 0, 'ERC721: mint timestamp query for nonexistent token'); + if (mintTimestamp == 0) revert Errors.ERC721Time_MintTimestampQueryForNonexistantToken(); return mintTimestamp; } /** - * @dev See {IERC721Time-mintTimestampOf} + * @dev See {IERC721Time-tokenDataOf} */ function tokenDataOf(uint256 tokenId) public @@ -106,7 +109,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { override returns (IERC721Time.TokenData memory) { - require(_exists(tokenId), 'ERC721: token data query for nonexistent token'); + if (!_exists(tokenId)) revert Errors.ERC721Time_TokenDataQueryForNonexistantToken(); return _tokenData[tokenId]; } @@ -135,7 +138,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { - require(_exists(tokenId), 'ERC721Metadata: URI query for nonexistent token'); + if (!_exists(tokenId)) revert Errors.ERC721Time_URIQueryForNonexistantToken(); string memory baseURI = _baseURI(); return @@ -156,12 +159,10 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721Time.ownerOf(tokenId); - require(to != owner, 'ERC721: approval to current owner'); + if (to == owner) revert Errors.ERC721Time_ApprovalToCurrentOwner(); - require( - _msgSender() == owner || isApprovedForAll(owner, _msgSender()), - 'ERC721: approve caller is not owner nor approved for all' - ); + if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) + revert Errors.ERC721Time_ApproveCallerNotOwnerOrApprovedForAll(); _approve(to, tokenId); } @@ -170,7 +171,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { - require(_exists(tokenId), 'ERC721: approved query for nonexistent token'); + if (!_exists(tokenId)) revert Errors.ERC721Time_ApprovedQueryForNonexistantToken(); return _tokenApprovals[tokenId]; } @@ -179,7 +180,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { - require(operator != _msgSender(), 'ERC721: approve to caller'); + if (operator == _msgSender()) revert Errors.ERC721Time_ApproveToCaller(); _setOperatorApproval(_msgSender(), operator, approved); } @@ -206,10 +207,8 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length - require( - _isApprovedOrOwner(_msgSender(), tokenId), - 'ERC721: transfer caller is not owner nor approved' - ); + if (!_isApprovedOrOwner(_msgSender(), tokenId)) + revert Errors.ERC721Time_TransferCallerNotOwnerOrApproved(); _transfer(from, to, tokenId); } @@ -234,13 +233,24 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { uint256 tokenId, bytes memory _data ) public virtual override { - require( - _isApprovedOrOwner(_msgSender(), tokenId), - 'ERC721: transfer caller is not owner nor approved' - ); + if (!_isApprovedOrOwner(_msgSender(), tokenId)) + revert Errors.ERC721Time_TransferCallerNotOwnerOrApproved(); _safeTransfer(from, to, tokenId, _data); } + /** + * @notice Returns the owner of the `tokenId` token. + * + * @dev It is prefixed as `unsafe` as it does not revert when the token does not exist. + * + * @param tokenId The token which owner is being queried. + * + * @return address The address owning the given token, zero address if the token does not exist. + */ + function _unsafeOwnerOf(uint256 tokenId) internal view returns (address) { + return _tokenData[tokenId].owner; + } + /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. @@ -266,10 +276,8 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { bytes memory _data ) internal virtual { _transfer(from, to, tokenId); - require( - _checkOnERC721Received(from, to, tokenId, _data), - 'ERC721: transfer to non ERC721Receiver implementer' - ); + if (!_checkOnERC721Received(from, to, tokenId, _data)) + revert Errors.ERC721Time_TransferToNonERC721ReceiverImplementer(); } /** @@ -297,7 +305,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { virtual returns (bool) { - require(_exists(tokenId), 'ERC721: operator query for nonexistent token'); + if (!_exists(tokenId)) revert Errors.ERC721Time_OperatorQueryForNonexistantToken(); address owner = ERC721Time.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || @@ -328,10 +336,8 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { bytes memory _data ) internal virtual { _mint(to, tokenId); - require( - _checkOnERC721Received(address(0), to, tokenId, _data), - 'ERC721: transfer to non ERC721Receiver implementer' - ); + if (!_checkOnERC721Received(address(0), to, tokenId, _data)) + revert Errors.ERC721Time_TransferToNonERC721ReceiverImplementer(); } /** @@ -347,12 +353,14 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { - require(to != address(0), 'ERC721: mint to the zero address'); - require(!_exists(tokenId), 'ERC721: token already minted'); + if (to == address(0)) revert Errors.ERC721Time_MintToZeroAddress(); + if (_exists(tokenId)) revert Errors.ERC721Time_TokenAlreadyMinted(); _beforeTokenTransfer(address(0), to, tokenId); - _balances[to] += 1; + unchecked { + ++_balances[to]; + } _tokenData[tokenId].owner = to; _tokenData[tokenId].mintTimestamp = uint96(block.timestamp); @@ -377,7 +385,9 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { // Clear approvals _approve(address(0), tokenId); - _balances[owner] -= 1; + unchecked { + --_balances[owner]; + } delete _tokenData[tokenId]; emit Transfer(owner, address(0), tokenId); @@ -399,16 +409,19 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { address to, uint256 tokenId ) internal virtual { - require(ERC721Time.ownerOf(tokenId) == from, 'ERC721: transfer of token that is not own'); - require(to != address(0), 'ERC721: transfer to the zero address'); + if (ERC721Time.ownerOf(tokenId) != from) + revert Errors.ERC721Time_TransferOfTokenThatIsNotOwn(); + if (to == address(0)) revert Errors.ERC721Time_TransferToZeroAddress(); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); - _balances[from] -= 1; - _balances[to] += 1; + unchecked { + --_balances[from]; + ++_balances[to]; + } _tokenData[tokenId].owner = to; emit Transfer(from, to, tokenId); @@ -462,7 +475,7 @@ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { - revert('ERC721: transfer to non ERC721Receiver implementer'); + revert Errors.ERC721Time_TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) diff --git a/contracts/core/base/HubRestricted.sol b/contracts/core/base/HubRestricted.sol new file mode 100644 index 0000000..df10884 --- /dev/null +++ b/contracts/core/base/HubRestricted.sol @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {Errors} from '../../libraries/Errors.sol'; +import {Events} from '../../libraries/Events.sol'; + +/** + * @title HubRestricted + * @author Lens Protocol + * + * @notice This abstract contract adds a public `HUB` immutable field, validations when setting it, as well + * as an `onlyHub` modifier, to inherit from contracts that have functions restricted to be only called by the Lens hub. + */ +abstract contract HubRestricted { + address public immutable HUB; + + modifier onlyHub() { + if (msg.sender != HUB) { + revert Errors.NotHub(); + } + _; + } + + constructor(address hub) { + if (hub == address(0)) { + revert Errors.InitParamsInvalid(); + } + HUB = hub; + } +} diff --git a/contracts/core/base/LensMultiState.sol b/contracts/core/base/LensMultiState.sol index e58f8f0..522936a 100644 --- a/contracts/core/base/LensMultiState.sol +++ b/contracts/core/base/LensMultiState.sol @@ -1,21 +1,23 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Events} from '../../libraries/Events.sol'; import {DataTypes} from '../../libraries/DataTypes.sol'; import {Errors} from '../../libraries/Errors.sol'; +import {ILensMultiState} from '../../interfaces/ILensMultiState.sol'; /** * @title LensMultiState * - * @notice This is an abstract contract that implements internal LensHub state setting and validation. + * @notice This is an abstract contract that implements internal LensHub state validation. Setting + * is delegated to the GeneralLib. * * whenNotPaused: Either publishingPaused or Unpaused. * whenPublishingEnabled: When Unpaused only. */ -abstract contract LensMultiState { - DataTypes.ProtocolState private _state; +abstract contract LensMultiState is ILensMultiState { + DataTypes.ProtocolState private _state; // slot 12 modifier whenNotPaused() { _validateNotPaused(); @@ -35,16 +37,10 @@ abstract contract LensMultiState { * 1: PublishingPaused * 2: Paused */ - function getState() external view returns (DataTypes.ProtocolState) { + function getState() external view override returns (DataTypes.ProtocolState) { return _state; } - function _setState(DataTypes.ProtocolState newState) internal { - DataTypes.ProtocolState prevState = _state; - _state = newState; - emit Events.StateSet(msg.sender, prevState, newState, block.timestamp); - } - function _validatePublishingEnabled() internal view { if (_state != DataTypes.ProtocolState.Unpaused) { revert Errors.PublishingPaused(); diff --git a/contracts/core/base/LensNFTBase.sol b/contracts/core/base/LensNFTBase.sol index d6b0a77..f7f4921 100644 --- a/contracts/core/base/LensNFTBase.sol +++ b/contracts/core/base/LensNFTBase.sol @@ -1,11 +1,12 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ILensNFTBase} from '../../interfaces/ILensNFTBase.sol'; import {Errors} from '../../libraries/Errors.sol'; import {DataTypes} from '../../libraries/DataTypes.sol'; import {Events} from '../../libraries/Events.sol'; +import {MetaTxHelpers} from '../../libraries/helpers/MetaTxHelpers.sol'; import {ERC721Time} from './ERC721Time.sol'; import {ERC721Enumerable} from './ERC721Enumerable.sol'; @@ -55,11 +56,11 @@ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { address spender, uint256 tokenId, DataTypes.EIP712Signature calldata sig - ) external override { + ) external virtual override { if (spender == address(0)) revert Errors.ZeroSpender(); address owner = ownerOf(tokenId); unchecked { - _validateRecoveredAddress( + MetaTxHelpers._validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( @@ -84,10 +85,10 @@ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { address operator, bool approved, DataTypes.EIP712Signature calldata sig - ) external override { + ) external virtual override { if (operator == address(0)) revert Errors.ZeroSpender(); unchecked { - _validateRecoveredAddress( + MetaTxHelpers._validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( @@ -108,7 +109,7 @@ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { } /// @inheritdoc ILensNFTBase - function getDomainSeparator() external view override returns (bytes32) { + function getDomainSeparator() external view virtual override returns (bytes32) { return _calculateDomainSeparator(); } @@ -126,7 +127,7 @@ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { { address owner = ownerOf(tokenId); unchecked { - _validateRecoveredAddress( + MetaTxHelpers._validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( @@ -144,20 +145,6 @@ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { _burn(tokenId); } - /** - * @dev Wrapper for ecrecover to reduce code size, used in meta-tx specific functions. - */ - function _validateRecoveredAddress( - bytes32 digest, - address expectedAddress, - DataTypes.EIP712Signature calldata sig - ) internal view { - if (sig.deadline < block.timestamp) revert Errors.SignatureExpired(); - address recoveredAddress = ecrecover(digest, sig.v, sig.r, sig.s); - if (recoveredAddress == address(0) || recoveredAddress != expectedAddress) - revert Errors.SignatureInvalid(); - } - /** * @dev Calculates EIP712 DOMAIN_SEPARATOR based on the current contract and chain ID. */ diff --git a/contracts/core/modules/FeeModuleBase.sol b/contracts/core/modules/FeeModuleBase.sol index a7c6c8f..081d84c 100644 --- a/contracts/core/modules/FeeModuleBase.sol +++ b/contracts/core/modules/FeeModuleBase.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Errors} from '../../libraries/Errors.sol'; import {Events} from '../../libraries/Events.sol'; diff --git a/contracts/core/modules/FollowValidationModuleBase.sol b/contracts/core/modules/FollowValidationModuleBase.sol index c1d3c40..c64ce6d 100644 --- a/contracts/core/modules/FollowValidationModuleBase.sol +++ b/contracts/core/modules/FollowValidationModuleBase.sol @@ -1,8 +1,8 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {IFollowModule} from '../../interfaces/IFollowModule.sol'; +import {IFollowModuleLegacy} from '../../interfaces/IFollowModuleLegacy.sol'; import {ILensHub} from '../../interfaces/ILensHub.sol'; import {Errors} from '../../libraries/Errors.sol'; import {Events} from '../../libraries/Events.sol'; @@ -33,7 +33,7 @@ abstract contract FollowValidationModuleBase is ModuleBase { address followModule = ILensHub(HUB).getFollowModule(profileId); bool isFollowing; if (followModule != address(0)) { - isFollowing = IFollowModule(followModule).isFollowing(profileId, user, 0); + isFollowing = IFollowModuleLegacy(followModule).isFollowing(0, profileId, user, 0); } else { address followNFT = ILensHub(HUB).getFollowNFT(profileId); isFollowing = followNFT != address(0) && IERC721(followNFT).balanceOf(user) != 0; diff --git a/contracts/core/modules/ModuleBase.sol b/contracts/core/modules/ModuleBase.sol index 6e29a66..e0e9757 100644 --- a/contracts/core/modules/ModuleBase.sol +++ b/contracts/core/modules/ModuleBase.sol @@ -1,28 +1,20 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Errors} from '../../libraries/Errors.sol'; import {Events} from '../../libraries/Events.sol'; +import {HubRestricted} from '../base/HubRestricted.sol'; /** * @title ModuleBase * @author Lens Protocol * - * @notice This abstract contract adds a public `HUB` immutable to inheriting modules, as well as an - * `onlyHub` modifier. + * @notice This contract fires an event at construction, to be inherited by other modules, in addition to the + * HubRestricted contract features. */ -abstract contract ModuleBase { - address public immutable HUB; - - modifier onlyHub() { - if (msg.sender != HUB) revert Errors.NotHub(); - _; - } - - constructor(address hub) { - if (hub == address(0)) revert Errors.InitParamsInvalid(); - HUB = hub; +abstract contract ModuleBase is HubRestricted { + constructor(address hub) HubRestricted(hub) { emit Events.ModuleBaseConstructed(hub, block.timestamp); } } diff --git a/contracts/core/modules/ModuleGlobals.sol b/contracts/core/modules/ModuleGlobals.sol index 16135da..5564b99 100644 --- a/contracts/core/modules/ModuleGlobals.sol +++ b/contracts/core/modules/ModuleGlobals.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Errors} from '../../libraries/Errors.sol'; import {Events} from '../../libraries/Events.sol'; diff --git a/contracts/core/modules/collect/FeeCollectModule.sol b/contracts/core/modules/collect/FeeCollectModule.sol index c0641e9..c6690ca 100644 --- a/contracts/core/modules/collect/FeeCollectModule.sol +++ b/contracts/core/modules/collect/FeeCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -61,6 +61,7 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect */ function initializePublicationCollectModule( uint256 profileId, + address, uint256 pubId, bytes calldata data ) external override onlyHub returns (bytes memory) { @@ -94,7 +95,9 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect */ function processCollect( uint256 referrerProfileId, + uint256, address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -102,9 +105,9 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect if (_dataByPublicationByProfile[profileId][pubId].followerOnly) _checkFollowValidity(profileId, collector); if (referrerProfileId == profileId) { - _processCollect(collector, profileId, pubId, data); + _processCollect(executor, profileId, pubId, data); } else { - _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + _processCollectWithReferral(referrerProfileId, executor, profileId, pubId, data); } } @@ -126,7 +129,7 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect } function _processCollect( - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -140,14 +143,14 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; uint256 adjustedAmount = amount - treasuryAmount; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } function _processCollectWithReferral( uint256 referrerProfileId, - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -177,12 +180,12 @@ contract FeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICollect address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); - IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + IERC20(currency).safeTransferFrom(executor, referralRecipient, referralAmount); } address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } } diff --git a/contracts/core/modules/collect/FreeCollectModule.sol b/contracts/core/modules/collect/FreeCollectModule.sol index 836fc8f..8851e11 100644 --- a/contracts/core/modules/collect/FreeCollectModule.sol +++ b/contracts/core/modules/collect/FreeCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {ModuleBase} from '../ModuleBase.sol'; @@ -24,6 +24,7 @@ contract FreeCollectModule is FollowValidationModuleBase, ICollectModule { */ function initializePublicationCollectModule( uint256 profileId, + address, uint256 pubId, bytes calldata data ) external override onlyHub returns (bytes memory) { @@ -37,11 +38,13 @@ contract FreeCollectModule is FollowValidationModuleBase, ICollectModule { * 1. Ensuring the collector is a follower, if needed */ function processCollect( - uint256 referrerProfileId, + uint256, + uint256, address collector, + address, uint256 profileId, uint256 pubId, - bytes calldata data + bytes calldata ) external view override { if (_followerOnlyByPublicationByProfile[profileId][pubId]) _checkFollowValidity(profileId, collector); diff --git a/contracts/core/modules/collect/LimitedFeeCollectModule.sol b/contracts/core/modules/collect/LimitedFeeCollectModule.sol index 140d954..7061d93 100644 --- a/contracts/core/modules/collect/LimitedFeeCollectModule.sol +++ b/contracts/core/modules/collect/LimitedFeeCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -66,6 +66,7 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I */ function initializePublicationCollectModule( uint256 profileId, + address, uint256 pubId, bytes calldata data ) external override onlyHub returns (bytes memory) { @@ -103,7 +104,9 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I */ function processCollect( uint256 referrerProfileId, + uint256, address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -111,16 +114,18 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I if (_dataByPublicationByProfile[profileId][pubId].followerOnly) _checkFollowValidity(profileId, collector); if ( - _dataByPublicationByProfile[profileId][pubId].currentCollects >= + _dataByPublicationByProfile[profileId][pubId].currentCollects == _dataByPublicationByProfile[profileId][pubId].collectLimit ) { revert Errors.MintLimitExceeded(); } else { - ++_dataByPublicationByProfile[profileId][pubId].currentCollects; + unchecked { + ++_dataByPublicationByProfile[profileId][pubId].currentCollects; + } if (referrerProfileId == profileId) { - _processCollect(collector, profileId, pubId, data); + _processCollect(executor, profileId, pubId, data); } else { - _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + _processCollectWithReferral(referrerProfileId, executor, profileId, pubId, data); } } } @@ -143,7 +148,7 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I } function _processCollect( - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -157,14 +162,14 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; uint256 adjustedAmount = amount - treasuryAmount; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } function _processCollectWithReferral( uint256 referrerProfileId, - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -194,12 +199,12 @@ contract LimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, I address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); - IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + IERC20(currency).safeTransferFrom(executor, referralRecipient, referralAmount); } address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } } diff --git a/contracts/core/modules/collect/LimitedTimedFeeCollectModule.sol b/contracts/core/modules/collect/LimitedTimedFeeCollectModule.sol index 0417ce6..dd5ce8b 100644 --- a/contracts/core/modules/collect/LimitedTimedFeeCollectModule.sol +++ b/contracts/core/modules/collect/LimitedTimedFeeCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -71,6 +71,7 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa */ function initializePublicationCollectModule( uint256 profileId, + address, uint256 pubId, bytes calldata data ) external override onlyHub returns (bytes memory) { @@ -123,7 +124,9 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa */ function processCollect( uint256 referrerProfileId, + uint256, address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -141,9 +144,9 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa } else { ++_dataByPublicationByProfile[profileId][pubId].currentCollects; if (referrerProfileId == profileId) { - _processCollect(collector, profileId, pubId, data); + _processCollect(executor, profileId, pubId, data); } else { - _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + _processCollectWithReferral(referrerProfileId, executor, profileId, pubId, data); } } } @@ -166,7 +169,7 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa } function _processCollect( - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -180,14 +183,14 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; uint256 adjustedAmount = amount - treasuryAmount; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } function _processCollectWithReferral( uint256 referrerProfileId, - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -217,12 +220,12 @@ contract LimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBa address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); - IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + IERC20(currency).safeTransferFrom(executor, referralRecipient, referralAmount); } address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } } diff --git a/contracts/core/modules/collect/RevertCollectModule.sol b/contracts/core/modules/collect/RevertCollectModule.sol index 5995e11..85ddf27 100644 --- a/contracts/core/modules/collect/RevertCollectModule.sol +++ b/contracts/core/modules/collect/RevertCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -18,9 +18,10 @@ contract RevertCollectModule is ICollectModule { * @dev There is nothing needed at initialization. */ function initializePublicationCollectModule( - uint256 profileId, - uint256 pubId, - bytes calldata data + uint256, + address, + uint256, + bytes calldata ) external pure override returns (bytes memory) { return new bytes(0); } @@ -30,11 +31,13 @@ contract RevertCollectModule is ICollectModule { * 1. Always reverting */ function processCollect( - uint256 referrerProfileId, - address collector, - uint256 profileId, - uint256 pubId, - bytes calldata data + uint256, + uint256, + address, + address, + uint256, + uint256, + bytes calldata ) external pure override { revert Errors.CollectNotAllowed(); } diff --git a/contracts/core/modules/collect/TimedFeeCollectModule.sol b/contracts/core/modules/collect/TimedFeeCollectModule.sol index 3674d5b..935ec56 100644 --- a/contracts/core/modules/collect/TimedFeeCollectModule.sol +++ b/contracts/core/modules/collect/TimedFeeCollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ICollectModule} from '../../../interfaces/ICollectModule.sol'; import {IFollowModule} from '../../../interfaces/IFollowModule.sol'; @@ -70,6 +70,7 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo */ function initializePublicationCollectModule( uint256 profileId, + address, uint256 pubId, bytes calldata data ) external override onlyHub returns (bytes memory) { @@ -109,7 +110,9 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo */ function processCollect( uint256 referrerProfileId, + uint256, address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -120,9 +123,9 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo if (block.timestamp > endTimestamp) revert Errors.CollectExpired(); if (referrerProfileId == profileId) { - _processCollect(collector, profileId, pubId, data); + _processCollect(executor, profileId, pubId, data); } else { - _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + _processCollectWithReferral(referrerProfileId, executor, profileId, pubId, data); } } @@ -144,7 +147,7 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo } function _processCollect( - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -158,14 +161,14 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; uint256 adjustedAmount = amount - treasuryAmount; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } function _processCollectWithReferral( uint256 referrerProfileId, - address collector, + address executor, uint256 profileId, uint256 pubId, bytes calldata data @@ -195,12 +198,12 @@ contract TimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, ICo address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); - IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + IERC20(currency).safeTransferFrom(executor, referralRecipient, referralAmount); } address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; - IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } } diff --git a/contracts/core/modules/deprecated/collect/DeprecatedFeeCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedFeeCollectModule.sol new file mode 100644 index 0000000..da5d1f6 --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedFeeCollectModule.sol @@ -0,0 +1,188 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {FeeModuleBase} from '../../FeeModuleBase.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; +import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @notice A struct containing the necessary data to execute collect actions on a publication. + * + * @param amount The collecting cost associated with this publication. + * @param currency The currency associated with this publication. + * @param recipient The recipient address associated with this publication. + * @param referralFee The referral fee associated with this publication. + * @param followerOnly Whether only followers should be able to collect. + */ +struct ProfilePublicationData { + uint256 amount; + address currency; + address recipient; + uint16 referralFee; + bool followerOnly; +} + +/** + * @title FeeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface and + * the FeeCollectModuleBase abstract contract. + * + * This module works by allowing unlimited collects for a publication at a given price. + */ +contract DeprecatedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, IDeprecatedCollectModule { + using SafeERC20 for IERC20; + + mapping(uint256 => mapping(uint256 => ProfilePublicationData)) + internal _dataByPublicationByProfile; + + constructor(address hub, address moduleGlobals) FeeModuleBase(moduleGlobals) ModuleBase(hub) {} + + /** + * @notice This collect module levies a fee on collects and supports referrals. Thus, we need to decode data. + * + * @param profileId The token ID of the profile of the publisher, passed by the hub. + * @param pubId The publication ID of the newly created publication, passed by the hub. + * @param data The arbitrary data parameter, decoded into: + * uint256 amount: The currency total amount to levy. + * address currency: The currency address, must be internally whitelisted. + * address recipient: The custom recipient address to direct earnings to. + * uint16 referralFee: The referral fee to set. + * bool followerOnly: Whether only followers should be able to collect. + * + * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub returns (bytes memory) { + ( + uint256 amount, + address currency, + address recipient, + uint16 referralFee, + bool followerOnly + ) = abi.decode(data, (uint256, address, address, uint16, bool)); + if ( + !_currencyWhitelisted(currency) || + recipient == address(0) || + referralFee > BPS_MAX || + amount == 0 + ) revert Errors.InitParamsInvalid(); + + _dataByPublicationByProfile[profileId][pubId].amount = amount; + _dataByPublicationByProfile[profileId][pubId].currency = currency; + _dataByPublicationByProfile[profileId][pubId].recipient = recipient; + _dataByPublicationByProfile[profileId][pubId].referralFee = referralFee; + _dataByPublicationByProfile[profileId][pubId].followerOnly = followerOnly; + + return data; + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower + * 2. Charging a fee + */ + function processCollect( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external virtual override onlyHub { + if (_dataByPublicationByProfile[profileId][pubId].followerOnly) + _checkFollowValidity(profileId, collector); + if (referrerProfileId == profileId) { + _processCollect(collector, profileId, pubId, data); + } else { + _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + } + } + + /** + * @notice Returns the publication data for a given publication, or an empty struct if that publication was not + * initialized with this module. + * + * @param profileId The token ID of the profile mapped to the publication to query. + * @param pubId The publication ID of the publication to query. + * + * @return ProfilePublicationData The ProfilePublicationData struct mapped to that publication. + */ + function getPublicationData(uint256 profileId, uint256 pubId) + external + view + returns (ProfilePublicationData memory) + { + return _dataByPublicationByProfile[profileId][pubId]; + } + + function _processCollect( + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + (address treasury, uint16 treasuryFee) = _treasuryData(); + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; + uint256 adjustedAmount = amount - treasuryAmount; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } + + function _processCollectWithReferral( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + uint256 referralFee = _dataByPublicationByProfile[profileId][pubId].referralFee; + address treasury; + uint256 treasuryAmount; + + // Avoids stack too deep + { + uint16 treasuryFee; + (treasury, treasuryFee) = _treasuryData(); + treasuryAmount = (amount * treasuryFee) / BPS_MAX; + } + + uint256 adjustedAmount = amount - treasuryAmount; + + if (referralFee != 0) { + // The reason we levy the referral fee on the adjusted amount is so that referral fees + // don't bypass the treasury fee, in essence referrals pay their fair share to the treasury. + uint256 referralAmount = (adjustedAmount * referralFee) / BPS_MAX; + adjustedAmount = adjustedAmount - referralAmount; + + address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); + + IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + } + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } +} diff --git a/contracts/core/modules/deprecated/collect/DeprecatedFreeCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedFreeCollectModule.sol new file mode 100644 index 0000000..91334d7 --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedFreeCollectModule.sol @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; + +/** + * @title FreeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface. + * + * This module works by allowing all collects. + */ +contract DeprecatedFreeCollectModule is FollowValidationModuleBase, IDeprecatedCollectModule { + constructor(address hub) ModuleBase(hub) {} + + mapping(uint256 => mapping(uint256 => bool)) internal _followerOnlyByPublicationByProfile; + + /** + * @dev There is nothing needed at initialization. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub returns (bytes memory) { + bool followerOnly = abi.decode(data, (bool)); + if (followerOnly) _followerOnlyByPublicationByProfile[profileId][pubId] = true; + return data; + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower, if needed + */ + function processCollect( + uint256, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata + ) external view override { + if (_followerOnlyByPublicationByProfile[profileId][pubId]) + _checkFollowValidity(profileId, collector); + } +} diff --git a/contracts/core/modules/deprecated/collect/DeprecatedLimitedFeeCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedLimitedFeeCollectModule.sol new file mode 100644 index 0000000..55b201a --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedLimitedFeeCollectModule.sol @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {FeeModuleBase} from '../../FeeModuleBase.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; +import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @notice A struct containing the necessary data to execute collect actions on a publication. + * + * @param collectLimit The maximum number of collects for this publication. + * @param currentCollects The current number of collects for this publication. + * @param amount The collecting cost associated with this publication. + * @param currency The currency associated with this publication. + * @param recipient The recipient address associated with this publication. + * @param referralFee The referral fee associated with this publication. + * @param followerOnly Whether only followers should be able to collect. + */ +struct ProfilePublicationData { + uint256 collectLimit; + uint256 currentCollects; + uint256 amount; + address currency; + address recipient; + uint16 referralFee; + bool followerOnly; +} + +/** + * @title LimitedFeeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface and + * the FeeCollectModuleBase abstract contract. + * + * This module works by allowing limited collects for a publication indefinitely. + */ +contract DeprecatedLimitedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, IDeprecatedCollectModule { + using SafeERC20 for IERC20; + + mapping(uint256 => mapping(uint256 => ProfilePublicationData)) + internal _dataByPublicationByProfile; + + constructor(address hub, address moduleGlobals) FeeModuleBase(moduleGlobals) ModuleBase(hub) {} + + /** + * @notice This collect module levies a fee on collects and supports referrals. Thus, we need to decode data. + * + * @param profileId The profile ID of the publication to initialize this module for's publishing profile. + * @param pubId The publication ID of the publication to initialize this module for. + * @param data The arbitrary data parameter, decoded into: + * uint256 collectLimit: The maximum amount of collects. + * uint256 amount: The currency total amount to levy. + * address currency: The currency address, must be internally whitelisted. + * address recipient: The custom recipient address to direct earnings to. + * uint16 referralFee: The referral fee to set. + * bool followerOnly: Whether only followers should be able to collect. + * + * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub returns (bytes memory) { + ( + uint256 collectLimit, + uint256 amount, + address currency, + address recipient, + uint16 referralFee, + bool followerOnly + ) = abi.decode(data, (uint256, uint256, address, address, uint16, bool)); + if ( + collectLimit == 0 || + !_currencyWhitelisted(currency) || + recipient == address(0) || + referralFee > BPS_MAX || + amount == 0 + ) revert Errors.InitParamsInvalid(); + + _dataByPublicationByProfile[profileId][pubId].collectLimit = collectLimit; + _dataByPublicationByProfile[profileId][pubId].amount = amount; + _dataByPublicationByProfile[profileId][pubId].currency = currency; + _dataByPublicationByProfile[profileId][pubId].recipient = recipient; + _dataByPublicationByProfile[profileId][pubId].referralFee = referralFee; + _dataByPublicationByProfile[profileId][pubId].followerOnly = followerOnly; + + return data; + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower + * 2. Ensuring the collect does not pass the collect limit + * 3. Charging a fee + */ + function processCollect( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub { + if (_dataByPublicationByProfile[profileId][pubId].followerOnly) + _checkFollowValidity(profileId, collector); + if ( + _dataByPublicationByProfile[profileId][pubId].currentCollects >= + _dataByPublicationByProfile[profileId][pubId].collectLimit + ) { + revert Errors.MintLimitExceeded(); + } else { + ++_dataByPublicationByProfile[profileId][pubId].currentCollects; + if (referrerProfileId == profileId) { + _processCollect(collector, profileId, pubId, data); + } else { + _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + } + } + } + + /** + * @notice Returns the publication data for a given publication, or an empty struct if that publication was not + * initialized with this module. + * + * @param profileId The token ID of the profile mapped to the publication to query. + * @param pubId The publication ID of the publication to query. + * + * @return ProfilePublicationData The ProfilePublicationData struct mapped to that publication. + */ + function getPublicationData(uint256 profileId, uint256 pubId) + external + view + returns (ProfilePublicationData memory) + { + return _dataByPublicationByProfile[profileId][pubId]; + } + + function _processCollect( + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + (address treasury, uint16 treasuryFee) = _treasuryData(); + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; + uint256 adjustedAmount = amount - treasuryAmount; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } + + function _processCollectWithReferral( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + uint256 referralFee = _dataByPublicationByProfile[profileId][pubId].referralFee; + address treasury; + uint256 treasuryAmount; + + // Avoids stack too deep + { + uint16 treasuryFee; + (treasury, treasuryFee) = _treasuryData(); + treasuryAmount = (amount * treasuryFee) / BPS_MAX; + } + + uint256 adjustedAmount = amount - treasuryAmount; + + if (referralFee != 0) { + // The reason we levy the referral fee on the adjusted amount is so that referral fees + // don't bypass the treasury fee, in essence referrals pay their fair share to the treasury. + uint256 referralAmount = (adjustedAmount * referralFee) / BPS_MAX; + adjustedAmount = adjustedAmount - referralAmount; + + address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); + + IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + } + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } +} diff --git a/contracts/core/modules/deprecated/collect/DeprecatedLimitedTimedFeeCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedLimitedTimedFeeCollectModule.sol new file mode 100644 index 0000000..e72dc67 --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedLimitedTimedFeeCollectModule.sol @@ -0,0 +1,228 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {FeeModuleBase} from '../../FeeModuleBase.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; +import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @notice A struct containing the necessary data to execute collect actions on a publication. + * + * @param collectLimit The maximum number of collects for this publication. + * @param currentCollects The current number of collects for this publication. + * @param amount The collecting cost associated with this publication. + * @param currency The currency associated with this publication. + * @param recipient The recipient address associated with this publication. + * @param referralFee The referral fee associated with this publication. + * @param endTimestamp The end timestamp after which collecting is impossible. + * @param followerOnly Whether only followers should be able to collect. + */ +struct ProfilePublicationData { + uint256 collectLimit; + uint256 currentCollects; + uint256 amount; + address currency; + address recipient; + uint16 referralFee; + bool followerOnly; + uint40 endTimestamp; +} + +/** + * @title LimitedTimedFeeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface and + * the FeeCollectModuleBase abstract contract. To optimize on gas, this module uses a constant 24 hour maximum + * collection time. + * + * This module works by allowing limited collects for a publication within the allotted time with a given fee. + */ +contract DeprecatedLimitedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, IDeprecatedCollectModule { + using SafeERC20 for IERC20; + + uint24 internal constant ONE_DAY = 24 hours; + + mapping(uint256 => mapping(uint256 => ProfilePublicationData)) + internal _dataByPublicationByProfile; + + constructor(address hub, address moduleGlobals) FeeModuleBase(moduleGlobals) ModuleBase(hub) {} + + /** + * @notice This collect module levies a fee on collects and supports referrals. Thus, we need to decode data. + * + * @param profileId The profile ID of the publication to initialize this module for's publishing profile. + * @param pubId The publication ID of the publication to initialize this module for. + * @param data The arbitrary data parameter, decoded into: + * uint256 collectLimit: The maximum amount of collects. + * uint256 amount: The currency total amount to levy. + * address currency: The currency address, must be internally whitelisted. + * address recipient: The custom recipient address to direct earnings to. + * uint16 referralFee: The referral fee to set. + * bool followerOnly: Whether only followers should be able to collect. + * + * @return bytes An abi encoded bytes parameter, containing (in order): collectLimit, amount, currency, recipient, referral fee & end timestamp. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub returns (bytes memory) { + unchecked { + uint40 endTimestamp = uint40(block.timestamp) + ONE_DAY; + + ( + uint256 collectLimit, + uint256 amount, + address currency, + address recipient, + uint16 referralFee, + bool followerOnly + ) = abi.decode(data, (uint256, uint256, address, address, uint16, bool)); + if ( + collectLimit == 0 || + !_currencyWhitelisted(currency) || + recipient == address(0) || + referralFee > BPS_MAX || + amount == 0 + ) revert Errors.InitParamsInvalid(); + + _dataByPublicationByProfile[profileId][pubId].collectLimit = collectLimit; + _dataByPublicationByProfile[profileId][pubId].amount = amount; + _dataByPublicationByProfile[profileId][pubId].currency = currency; + _dataByPublicationByProfile[profileId][pubId].recipient = recipient; + _dataByPublicationByProfile[profileId][pubId].referralFee = referralFee; + _dataByPublicationByProfile[profileId][pubId].followerOnly = followerOnly; + _dataByPublicationByProfile[profileId][pubId].endTimestamp = endTimestamp; + + return + abi.encode( + collectLimit, + amount, + currency, + recipient, + referralFee, + followerOnly, + endTimestamp + ); + } + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower + * 2. Ensuring the current timestamp is less than or equal to the collect end timestamp + * 3. Ensuring the collect does not pass the collect limit + * 4. Charging a fee + */ + function processCollect( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub { + if (_dataByPublicationByProfile[profileId][pubId].followerOnly) + _checkFollowValidity(profileId, collector); + uint256 endTimestamp = _dataByPublicationByProfile[profileId][pubId].endTimestamp; + if (block.timestamp > endTimestamp) revert Errors.CollectExpired(); + + if ( + _dataByPublicationByProfile[profileId][pubId].currentCollects >= + _dataByPublicationByProfile[profileId][pubId].collectLimit + ) { + revert Errors.MintLimitExceeded(); + } else { + ++_dataByPublicationByProfile[profileId][pubId].currentCollects; + if (referrerProfileId == profileId) { + _processCollect(collector, profileId, pubId, data); + } else { + _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + } + } + } + + /** + * @notice Returns the publication data for a given publication, or an empty struct if that publication was not + * initialized with this module. + * + * @param profileId The token ID of the profile mapped to the publication to query. + * @param pubId The publication ID of the publication to query. + * + * @return ProfilepublicationData The ProfilePublicationData struct mapped to that publication. + */ + function getPublicationData(uint256 profileId, uint256 pubId) + external + view + returns (ProfilePublicationData memory) + { + return _dataByPublicationByProfile[profileId][pubId]; + } + + function _processCollect( + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + (address treasury, uint16 treasuryFee) = _treasuryData(); + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; + uint256 adjustedAmount = amount - treasuryAmount; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } + + function _processCollectWithReferral( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + uint256 referralFee = _dataByPublicationByProfile[profileId][pubId].referralFee; + address treasury; + uint256 treasuryAmount; + + // Avoids stack too deep + { + uint16 treasuryFee; + (treasury, treasuryFee) = _treasuryData(); + treasuryAmount = (amount * treasuryFee) / BPS_MAX; + } + + uint256 adjustedAmount = amount - treasuryAmount; + + if (referralFee != 0) { + // The reason we levy the referral fee on the adjusted amount is so that referral fees + // don't bypass the treasury fee, in essence referrals pay their fair share to the treasury. + uint256 referralAmount = (adjustedAmount * referralFee) / BPS_MAX; + adjustedAmount = adjustedAmount - referralAmount; + + address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); + + IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + } + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } +} diff --git a/contracts/core/modules/deprecated/collect/DeprecatedRevertCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedRevertCollectModule.sol new file mode 100644 index 0000000..618a46b --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedRevertCollectModule.sol @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; + +/** + * @title RevertCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface. + * + * This module works by disallowing all collects. + */ +contract DeprecatedRevertCollectModule is IDeprecatedCollectModule { + /** + * @dev There is nothing needed at initialization. + */ + function initializePublicationCollectModule( + uint256, + uint256, + bytes calldata + ) external pure override returns (bytes memory) { + return new bytes(0); + } + + /** + * @dev Processes a collect by: + * 1. Always reverting + */ + function processCollect( + uint256, + address, + uint256, + uint256, + bytes calldata + ) external pure override { + revert Errors.CollectNotAllowed(); + } +} diff --git a/contracts/core/modules/deprecated/collect/DeprecatedTimedFeeCollectModule.sol b/contracts/core/modules/deprecated/collect/DeprecatedTimedFeeCollectModule.sol new file mode 100644 index 0000000..00f31be --- /dev/null +++ b/contracts/core/modules/deprecated/collect/DeprecatedTimedFeeCollectModule.sol @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../../../../interfaces/IDeprecatedCollectModule.sol'; +import {ILensHub} from '../../../../interfaces/ILensHub.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {FeeModuleBase} from '../../FeeModuleBase.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; +import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @notice A struct containing the necessary data to execute collect actions on a publication. + * + * @param amount The collecting cost associated with this publication. + * @param currency The currency associated with this publication. + * @param recipient The recipient address associated with this publication. + * @param referralFee The referral fee associated with this publication. + * @param endTimestamp The end timestamp after which collecting is impossible. + * @param followerOnly Whether only followers should be able to collect. + */ +struct ProfilePublicationData { + uint256 amount; + address currency; + address recipient; + uint16 referralFee; + bool followerOnly; + uint40 endTimestamp; +} + +/** + * @title TimedFeeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface and + * the FeeCollectModuleBase abstract contract. To optimize on gas, this module uses a constant 24 hour maximum + * collection time. + * + * This module works by allowing unlimited collects for a publication within the allotted time with a given fee. + * + * NOTE: If data passed on initialization is empty, this module will only check for the time limit. + */ +contract DeprecatedTimedFeeCollectModule is FeeModuleBase, FollowValidationModuleBase, IDeprecatedCollectModule { + using SafeERC20 for IERC20; + + uint24 internal constant ONE_DAY = 24 hours; + + mapping(uint256 => mapping(uint256 => ProfilePublicationData)) + internal _dataByPublicationByProfile; + + constructor(address hub, address moduleGlobals) FeeModuleBase(moduleGlobals) ModuleBase(hub) {} + + /** + * @notice This collect module levies a fee on collects and supports referrals. Thus, we need to decode data. + * + * @param profileId The profile ID of the publication to initialize this module for's publishing profile. + * @param pubId The publication ID of the publication to initialize this module for. + * @param data The arbitrary data parameter, decoded into: + * uint256 amount: The currency total amount to levy. + * address currency: The currency address, must be internally whitelisted. + * address recipient: The custom recipient address to direct earnings to. + * uint16 referralFee: The referral fee to set. + * bool followerOnly: Whether only followers should be able to collect. + * + * @return bytes An abi encoded bytes parameter, containing (in order): amount, currency, recipient, referral fee & end timestamp. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub returns (bytes memory) { + unchecked { + uint40 endTimestamp = uint40(block.timestamp) + ONE_DAY; + + ( + uint256 amount, + address currency, + address recipient, + uint16 referralFee, + bool followerOnly + ) = abi.decode(data, (uint256, address, address, uint16, bool)); + if ( + !_currencyWhitelisted(currency) || + recipient == address(0) || + referralFee > BPS_MAX || + amount == 0 + ) revert Errors.InitParamsInvalid(); + + _dataByPublicationByProfile[profileId][pubId].amount = amount; + _dataByPublicationByProfile[profileId][pubId].currency = currency; + _dataByPublicationByProfile[profileId][pubId].recipient = recipient; + _dataByPublicationByProfile[profileId][pubId].referralFee = referralFee; + _dataByPublicationByProfile[profileId][pubId].followerOnly = followerOnly; + _dataByPublicationByProfile[profileId][pubId].endTimestamp = endTimestamp; + + return abi.encode(amount, currency, recipient, referralFee, followerOnly, endTimestamp); + } + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower + * 2. Ensuring the current timestamp is less than or equal to the collect end timestamp + * 3. Charging a fee + */ + function processCollect( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external override onlyHub { + if (_dataByPublicationByProfile[profileId][pubId].followerOnly) + _checkFollowValidity(profileId, collector); + uint256 endTimestamp = _dataByPublicationByProfile[profileId][pubId].endTimestamp; + if (block.timestamp > endTimestamp) revert Errors.CollectExpired(); + + if (referrerProfileId == profileId) { + _processCollect(collector, profileId, pubId, data); + } else { + _processCollectWithReferral(referrerProfileId, collector, profileId, pubId, data); + } + } + + /** + * @notice Returns the publication data for a given publication, or an empty struct if that publication was not + * initialized with this module. + * + * @param profileId The token ID of the profile mapped to the publication to query. + * @param pubId The publication ID of the publication to query. + * + * @return ProfilePublicationData The ProfilePublicationData struct mapped to that publication. + */ + function getPublicationData(uint256 profileId, uint256 pubId) + external + view + returns (ProfilePublicationData memory) + { + return _dataByPublicationByProfile[profileId][pubId]; + } + + function _processCollect( + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + (address treasury, uint16 treasuryFee) = _treasuryData(); + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; + uint256 adjustedAmount = amount - treasuryAmount; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } + + function _processCollectWithReferral( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) internal { + uint256 amount = _dataByPublicationByProfile[profileId][pubId].amount; + address currency = _dataByPublicationByProfile[profileId][pubId].currency; + _validateDataIsExpected(data, currency, amount); + + uint256 referralFee = _dataByPublicationByProfile[profileId][pubId].referralFee; + address treasury; + uint256 treasuryAmount; + + // Avoids stack too deep + { + uint16 treasuryFee; + (treasury, treasuryFee) = _treasuryData(); + treasuryAmount = (amount * treasuryFee) / BPS_MAX; + } + + uint256 adjustedAmount = amount - treasuryAmount; + + if (referralFee != 0) { + // The reason we levy the referral fee on the adjusted amount is so that referral fees + // don't bypass the treasury fee, in essence referrals pay their fair share to the treasury. + uint256 referralAmount = (adjustedAmount * referralFee) / BPS_MAX; + adjustedAmount = adjustedAmount - referralAmount; + + address referralRecipient = IERC721(HUB).ownerOf(referrerProfileId); + + IERC20(currency).safeTransferFrom(collector, referralRecipient, referralAmount); + } + address recipient = _dataByPublicationByProfile[profileId][pubId].recipient; + + IERC20(currency).safeTransferFrom(collector, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(collector, treasury, treasuryAmount); + } +} diff --git a/contracts/core/modules/deprecated/follow/DeprecatedApprovalFollowModule.sol b/contracts/core/modules/deprecated/follow/DeprecatedApprovalFollowModule.sol new file mode 100644 index 0000000..1657946 --- /dev/null +++ b/contracts/core/modules/deprecated/follow/DeprecatedApprovalFollowModule.sol @@ -0,0 +1,147 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {Errors} from '../../../../libraries/Errors.sol'; +import {Events} from '../../../../libraries/Events.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {DeprecatedFollowValidatorFollowModuleBase} from './DeprecatedFollowValidatorFollowModuleBase.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @title ApprovalFollowModule + * @author Lens Protocol + * + * @notice This follow module only allows addresses that are approved for a profile by the profile owner to follow. + */ +contract DeprecatedApprovalFollowModule is DeprecatedFollowValidatorFollowModuleBase { + // We use a triple nested mapping so that, on profile transfer, the previous approved address list is invalid; + mapping(address => mapping(uint256 => mapping(address => bool))) + internal _approvedByProfileByOwner; + + constructor(address hub) ModuleBase(hub) {} + + /** + * @notice A custom function that allows profile owners to customize approved addresses. + * + * @param profileId The profile ID to approve/disapprove follower addresses for. + * @param addresses The addresses to approve/disapprove for following the profile. + * @param toApprove Whether to approve or disapprove the addresses for following the profile. + */ + function approve( + uint256 profileId, + address[] calldata addresses, + bool[] calldata toApprove + ) external { + if (addresses.length != toApprove.length) revert Errors.InitParamsInvalid(); + address owner = IERC721(HUB).ownerOf(profileId); + if (msg.sender != owner) revert Errors.NotProfileOwner(); + + uint256 addressesLength = addresses.length; + for (uint256 i = 0; i < addressesLength; ) { + _approvedByProfileByOwner[owner][profileId][addresses[i]] = toApprove[i]; + unchecked { + ++i; + } + } + + emit Events.FollowsApproved(owner, profileId, addresses, toApprove, block.timestamp); + } + + /** + * @notice This follow module works on custom profile owner approvals. + * + * @param profileId The profile ID of the profile to initialize this module for. + * @param data The arbitrary data parameter, decoded into: + * address[] addresses: The array of addresses to approve initially. + * + * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. + */ + function initializeFollowModule(uint256 profileId, bytes calldata data) + external + override + onlyHub + returns (bytes memory) + { + address owner = IERC721(HUB).ownerOf(profileId); + + if (data.length > 0) { + address[] memory addresses = abi.decode(data, (address[])); + uint256 addressesLength = addresses.length; + for (uint256 i = 0; i < addressesLength; ) { + _approvedByProfileByOwner[owner][profileId][addresses[i]] = true; + unchecked { + ++i; + } + } + } + return data; + } + + /** + * @dev Processes a follow by: + * 1. Validating that the follower has been approved for that profile by the profile owner + */ + function processFollow( + address follower, + uint256 profileId, + bytes calldata + ) external override onlyHub { + address owner = IERC721(HUB).ownerOf(profileId); + if (!_approvedByProfileByOwner[owner][profileId][follower]) + revert Errors.FollowNotApproved(); + _approvedByProfileByOwner[owner][profileId][follower] = false; // prevents repeat follows + } + + /** + * @dev We don't need to execute any additional logic on transfers in this follow module. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external override {} + + /** + * @notice Returns whether the given address is approved for the profile owned by a given address. + * + * @param profileOwner The profile owner of the profile to query the approval with. + * @param profileId The token ID of the profile to query approval with. + * @param toCheck The address to query approval for. + * + * @return bool True if the address is approved and false otherwise. + */ + function isApproved( + address profileOwner, + uint256 profileId, + address toCheck + ) external view returns (bool) { + return _approvedByProfileByOwner[profileOwner][profileId][toCheck]; + } + + /** + * @notice Returns whether the given addresses are approved for the profile owned by a given address. + * + * @param profileOwner The profile owner of the profile to query the approvals with. + * @param profileId The token ID of the profile to query approvals with. + * @param toCheck The address array to query approvals for. + * + * @return bool[] true if the address at the specified index is approved and false otherwise. + */ + function isApprovedArray( + address profileOwner, + uint256 profileId, + address[] calldata toCheck + ) external view returns (bool[] memory) { + bool[] memory approved = new bool[](toCheck.length); + uint256 toCheckLength = toCheck.length; + for (uint256 i = 0; i < toCheckLength; ) { + approved[i] = _approvedByProfileByOwner[profileOwner][profileId][toCheck[i]]; + unchecked { + ++i; + } + } + return approved; + } +} diff --git a/contracts/core/modules/deprecated/follow/DeprecatedFeeFollowModule.sol b/contracts/core/modules/deprecated/follow/DeprecatedFeeFollowModule.sol new file mode 100644 index 0000000..799fd88 --- /dev/null +++ b/contracts/core/modules/deprecated/follow/DeprecatedFeeFollowModule.sol @@ -0,0 +1,115 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {ILensHub} from '../../../../interfaces/ILensHub.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {FeeModuleBase} from '../../FeeModuleBase.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {DeprecatedFollowValidatorFollowModuleBase} from './DeprecatedFollowValidatorFollowModuleBase.sol'; +import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @notice A struct containing the necessary data to execute follow actions on a given profile. + * + * @param currency The currency associated with this profile. + * @param amount The following cost associated with this profile. + * @param recipient The recipient address associated with this profile. + */ +struct ProfileData { + address currency; + uint256 amount; + address recipient; +} + +/** + * @title FeeFollowModule + * @author Lens Protocol + * + * @notice This is a simple Lens FollowModule implementation, inheriting from the IFollowModule interface, but with additional + * variables that can be controlled by governance, such as the governance & treasury addresses as well as the treasury fee. + */ +contract DeprecatedFeeFollowModule is FeeModuleBase, DeprecatedFollowValidatorFollowModuleBase { + using SafeERC20 for IERC20; + + mapping(uint256 => ProfileData) internal _dataByProfile; + + constructor(address hub, address moduleGlobals) FeeModuleBase(moduleGlobals) ModuleBase(hub) {} + + /** + * @notice This follow module levies a fee on follows. + * + * @param profileId The profile ID of the profile to initialize this module for. + * @param data The arbitrary data parameter, decoded into: + * address currency: The currency address, must be internally whitelisted. + * uint256 amount: The currency total amount to levy. + * address recipient: The custom recipient address to direct earnings to. + * + * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. + */ + function initializeFollowModule(uint256 profileId, bytes calldata data) + external + override + onlyHub + returns (bytes memory) + { + (uint256 amount, address currency, address recipient) = abi.decode( + data, + (uint256, address, address) + ); + if (!_currencyWhitelisted(currency) || recipient == address(0) || amount == 0) + revert Errors.InitParamsInvalid(); + + _dataByProfile[profileId].amount = amount; + _dataByProfile[profileId].currency = currency; + _dataByProfile[profileId].recipient = recipient; + return data; + } + + /** + * @dev Processes a follow by: + * 1. Charging a fee + */ + function processFollow( + address follower, + uint256 profileId, + bytes calldata data + ) external override onlyHub { + uint256 amount = _dataByProfile[profileId].amount; + address currency = _dataByProfile[profileId].currency; + _validateDataIsExpected(data, currency, amount); + + (address treasury, uint16 treasuryFee) = _treasuryData(); + address recipient = _dataByProfile[profileId].recipient; + uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; + uint256 adjustedAmount = amount - treasuryAmount; + + IERC20(currency).safeTransferFrom(follower, recipient, adjustedAmount); + if (treasuryAmount > 0) + IERC20(currency).safeTransferFrom(follower, treasury, treasuryAmount); + } + + /** + * @dev We don't need to execute any additional logic on transfers in this follow module. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external override {} + + /** + * @notice Returns the profile data for a given profile, or an empty struct if that profile was not initialized + * with this module. + * + * @param profileId The token ID of the profile to query. + * + * @return ProfileData The ProfileData struct mapped to that profile. + */ + function getProfileData(uint256 profileId) external view returns (ProfileData memory) { + return _dataByProfile[profileId]; + } +} diff --git a/contracts/core/modules/deprecated/follow/DeprecatedFollowValidatorFollowModuleBase.sol b/contracts/core/modules/deprecated/follow/DeprecatedFollowValidatorFollowModuleBase.sol new file mode 100644 index 0000000..5155745 --- /dev/null +++ b/contracts/core/modules/deprecated/follow/DeprecatedFollowValidatorFollowModuleBase.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedFollowModule} from '../../../../interfaces/IDeprecatedFollowModule.sol'; +import {ILensHub} from '../../../../interfaces/ILensHub.sol'; +import {Errors} from '../../../../libraries/Errors.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @title FollowValidatorFollowModuleBase + * @author Lens Protocol + * + * @notice This abstract contract adds the default expected behavior for follow validation in a follow module + * to inheriting contracts. + */ +abstract contract DeprecatedFollowValidatorFollowModuleBase is ModuleBase, IDeprecatedFollowModule { + /** + * @notice Standard function to validate follow NFT ownership. This module is agnostic to follow NFT token IDs + * and other properties. + */ + function isFollowing( + uint256 profileId, + address follower, + uint256 followNFTTokenId + ) external view override returns (bool) { + address followNFT = ILensHub(HUB).getFollowNFT(profileId); + if (followNFT == address(0)) { + return false; + } else { + return + followNFTTokenId == 0 + ? IERC721(followNFT).balanceOf(follower) != 0 + : IERC721(followNFT).ownerOf(followNFTTokenId) == follower; + } + } +} diff --git a/contracts/core/modules/deprecated/follow/DeprecatedProfileFollowModule.sol b/contracts/core/modules/deprecated/follow/DeprecatedProfileFollowModule.sol new file mode 100644 index 0000000..a774621 --- /dev/null +++ b/contracts/core/modules/deprecated/follow/DeprecatedProfileFollowModule.sol @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {Errors} from '../../../../libraries/Errors.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {DeprecatedFollowValidatorFollowModuleBase} from './DeprecatedFollowValidatorFollowModuleBase.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @title ProfileFollowModule + * @author Lens Protocol + * + * @notice A Lens Profile NFT token-gated follow module with single follow per token validation. + */ +contract DeprecatedProfileFollowModule is DeprecatedFollowValidatorFollowModuleBase { + /** + * Given two profile IDs tells if the former has already been used to follow the latter. + */ + mapping(uint256 => mapping(uint256 => bool)) public isProfileFollowing; + + constructor(address hub) ModuleBase(hub) {} + + /** + * @notice This follow module allows users to follow using a profile once. + * + * @return bytes Empty bytes. + */ + function initializeFollowModule(uint256, bytes calldata) + external + view + override + onlyHub + returns (bytes memory) + { + return new bytes(0); + } + + /** + * @dev Processes a follow by: + * 1. Validating that the follower owns the profile passed through the data param. + * 2. Validating that the profile that is being used to execute the follow was not already used for following the + * given profile. + */ + function processFollow( + address follower, + uint256 profileId, + bytes calldata data + ) external override onlyHub { + uint256 followerProfileId = abi.decode(data, (uint256)); + if (IERC721(HUB).ownerOf(followerProfileId) != follower) { + revert Errors.NotProfileOwner(); + } + if (isProfileFollowing[followerProfileId][profileId]) { + revert Errors.FollowInvalid(); + } else { + isProfileFollowing[followerProfileId][profileId] = true; + } + } + + /** + * @dev We don't need to execute any additional logic on transfers in this follow module. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external override {} +} diff --git a/contracts/core/modules/deprecated/follow/DeprecatedRevertFollowModule.sol b/contracts/core/modules/deprecated/follow/DeprecatedRevertFollowModule.sol new file mode 100644 index 0000000..b180b1f --- /dev/null +++ b/contracts/core/modules/deprecated/follow/DeprecatedRevertFollowModule.sol @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {Errors} from '../../../../libraries/Errors.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {DeprecatedFollowValidatorFollowModuleBase} from './DeprecatedFollowValidatorFollowModuleBase.sol'; + +/** + * @title RevertFollowModule + * @author Lens Protocol + * + * @notice This follow module rejects all follow attempts. + */ +contract DeprecatedRevertFollowModule is DeprecatedFollowValidatorFollowModuleBase { + constructor(address hub) ModuleBase(hub) {} + + /** + * @notice This follow module always reverts. + * + * @return bytes Empty bytes. + */ + function initializeFollowModule(uint256, bytes calldata) + external + view + override + onlyHub + returns (bytes memory) + { + return new bytes(0); + } + + /** + * @dev Processes a follow by rejecting it reverting the transaction. + */ + function processFollow( + address, + uint256, + bytes calldata + ) external view override onlyHub { + revert Errors.FollowInvalid(); + } + + /** + * @dev We don't need to execute any additional logic on transfers in this follow module. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external override {} +} diff --git a/contracts/core/modules/deprecated/reference/DeprecatedFollowerOnlyReferenceModule.sol b/contracts/core/modules/deprecated/reference/DeprecatedFollowerOnlyReferenceModule.sol new file mode 100644 index 0000000..e051436 --- /dev/null +++ b/contracts/core/modules/deprecated/reference/DeprecatedFollowerOnlyReferenceModule.sol @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedReferenceModule} from '../../../../interfaces/IDeprecatedReferenceModule.sol'; +import {ModuleBase} from '../../ModuleBase.sol'; +import {FollowValidationModuleBase} from '../../FollowValidationModuleBase.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; + +/** + * @title FollowerOnlyReferenceModule + * @author Lens Protocol + * + * @notice A simple reference module that validates that comments or mirrors originate from a profile owned + * by a follower. + */ +contract DeprecatedFollowerOnlyReferenceModule is FollowValidationModuleBase, IDeprecatedReferenceModule { + constructor(address hub) ModuleBase(hub) {} + + /** + * @dev There is nothing needed at initialization. + */ + function initializeReferenceModule( + uint256, + uint256, + bytes calldata + ) external pure override returns (bytes memory) { + return new bytes(0); + } + + /** + * @notice Validates that the commenting profile's owner is a follower. + * + * NOTE: We don't need to care what the pointed publication is in this context. + */ + function processComment( + uint256 profileId, + uint256 profileIdPointed, + uint256, + bytes calldata + ) external view override { + address commentCreator = IERC721(HUB).ownerOf(profileId); + _checkFollowValidity(profileIdPointed, commentCreator); + } + + /** + * @notice Validates that the mirroring profile's owner is a follower. + * + * NOTE: We don't need to care what the pointed publication is in this context. + */ + function processMirror( + uint256 profileId, + uint256 profileIdPointed, + uint256, + bytes calldata + ) external view override { + address mirrorCreator = IERC721(HUB).ownerOf(profileId); + _checkFollowValidity(profileIdPointed, mirrorCreator); + } +} diff --git a/contracts/core/modules/follow/ApprovalFollowModule.sol b/contracts/core/modules/follow/ApprovalFollowModule.sol index cab93e2..1645de7 100644 --- a/contracts/core/modules/follow/ApprovalFollowModule.sol +++ b/contracts/core/modules/follow/ApprovalFollowModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IFollowModule} from '../../../interfaces/IFollowModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -58,12 +58,11 @@ contract ApprovalFollowModule is FollowValidatorFollowModuleBase { * * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. */ - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - override - onlyHub - returns (bytes memory) - { + function initializeFollowModule( + uint256 profileId, + address, + bytes calldata data + ) external override onlyHub returns (bytes memory) { address owner = IERC721(HUB).ownerOf(profileId); if (data.length > 0) { @@ -84,9 +83,11 @@ contract ApprovalFollowModule is FollowValidatorFollowModuleBase { * 1. Validating that the follower has been approved for that profile by the profile owner */ function processFollow( + uint256, address follower, + address, uint256 profileId, - bytes calldata data + bytes calldata ) external override onlyHub { address owner = IERC721(HUB).ownerOf(profileId); if (!_approvedByProfileByOwner[owner][profileId][follower]) diff --git a/contracts/core/modules/follow/FeeFollowModule.sol b/contracts/core/modules/follow/FeeFollowModule.sol index 4bb479b..c21c1f3 100644 --- a/contracts/core/modules/follow/FeeFollowModule.sol +++ b/contracts/core/modules/follow/FeeFollowModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IFollowModule} from '../../../interfaces/IFollowModule.sol'; import {ILensHub} from '../../../interfaces/ILensHub.sol'; @@ -50,12 +50,11 @@ contract FeeFollowModule is FeeModuleBase, FollowValidatorFollowModuleBase { * * @return bytes An abi encoded bytes parameter, which is the same as the passed data parameter. */ - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - override - onlyHub - returns (bytes memory) - { + function initializeFollowModule( + uint256 profileId, + address, + bytes calldata data + ) external override onlyHub returns (bytes memory) { (uint256 amount, address currency, address recipient) = abi.decode( data, (uint256, address, address) @@ -74,7 +73,9 @@ contract FeeFollowModule is FeeModuleBase, FollowValidatorFollowModuleBase { * 1. Charging a fee */ function processFollow( - address follower, + uint256, + address, + address executor, uint256 profileId, bytes calldata data ) external override onlyHub { @@ -87,9 +88,9 @@ contract FeeFollowModule is FeeModuleBase, FollowValidatorFollowModuleBase { uint256 treasuryAmount = (amount * treasuryFee) / BPS_MAX; uint256 adjustedAmount = amount - treasuryAmount; - IERC20(currency).safeTransferFrom(follower, recipient, adjustedAmount); + IERC20(currency).safeTransferFrom(executor, recipient, adjustedAmount); if (treasuryAmount > 0) - IERC20(currency).safeTransferFrom(follower, treasury, treasuryAmount); + IERC20(currency).safeTransferFrom(executor, treasury, treasuryAmount); } /** diff --git a/contracts/core/modules/follow/FollowValidatorFollowModuleBase.sol b/contracts/core/modules/follow/FollowValidatorFollowModuleBase.sol index c0e1ed8..03bc392 100644 --- a/contracts/core/modules/follow/FollowValidatorFollowModuleBase.sol +++ b/contracts/core/modules/follow/FollowValidatorFollowModuleBase.sol @@ -1,8 +1,8 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {IFollowModule} from '../../../interfaces/IFollowModule.sol'; +import {IFollowModuleLegacy} from '../../../interfaces/IFollowModuleLegacy.sol'; import {ILensHub} from '../../../interfaces/ILensHub.sol'; import {Errors} from '../../../libraries/Errors.sol'; import {ModuleBase} from '../ModuleBase.sol'; @@ -15,12 +15,13 @@ import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; * @notice This abstract contract adds the default expected behavior for follow validation in a follow module * to inheriting contracts. */ -abstract contract FollowValidatorFollowModuleBase is ModuleBase, IFollowModule { +abstract contract FollowValidatorFollowModuleBase is ModuleBase, IFollowModuleLegacy { /** * @notice Standard function to validate follow NFT ownership. This module is agnostic to follow NFT token IDs * and other properties. */ function isFollowing( + uint256, uint256 profileId, address follower, uint256 followNFTTokenId diff --git a/contracts/core/modules/follow/ProfileFollowModule.sol b/contracts/core/modules/follow/ProfileFollowModule.sol index 2afe6e4..2b60c71 100644 --- a/contracts/core/modules/follow/ProfileFollowModule.sol +++ b/contracts/core/modules/follow/ProfileFollowModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IFollowModule} from '../../../interfaces/IFollowModule.sol'; import {Errors} from '../../../libraries/Errors.sol'; @@ -25,17 +25,13 @@ contract ProfileFollowModule is FollowValidatorFollowModuleBase { /** * @notice This follow module works on custom profile owner approvals. * - * @param profileId The profile ID of the profile to initialize this module for. - * @param data The arbitrary data parameter, which in this particular module initialization will be just ignored. - * * @return bytes Empty bytes. */ - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - override - onlyHub - returns (bytes memory) - { + function initializeFollowModule( + uint256, + address, + bytes calldata + ) external view override onlyHub returns (bytes memory) { return new bytes(0); } @@ -46,7 +42,9 @@ contract ProfileFollowModule is FollowValidatorFollowModuleBase { * given profile. */ function processFollow( + uint256, address follower, + address, uint256 profileId, bytes calldata data ) external override onlyHub { diff --git a/contracts/core/modules/follow/RevertFollowModule.sol b/contracts/core/modules/follow/RevertFollowModule.sol index 6695583..79b6c1e 100644 --- a/contracts/core/modules/follow/RevertFollowModule.sol +++ b/contracts/core/modules/follow/RevertFollowModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Errors} from '../../../libraries/Errors.sol'; import {ModuleBase} from '../ModuleBase.sol'; @@ -16,30 +16,27 @@ contract RevertFollowModule is FollowValidatorFollowModuleBase { constructor(address hub) ModuleBase(hub) {} /** - * @notice This follow module works on custom profile owner approvals. - * - * @param profileId The profile ID of the profile to initialize this module for. - * @param data The arbitrary data parameter, which in this particular module initialization will be just ignored. + * @notice This follow module always reverts. * * @return bytes Empty bytes. */ - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - view - override - onlyHub - returns (bytes memory) - { + function initializeFollowModule( + uint256, + address, + bytes calldata + ) external view override onlyHub returns (bytes memory) { return new bytes(0); } /** - * @dev Processes a follow by rejecting it reverting the transaction. + * @dev Processes a follow by rejecting it and reverting the transaction. */ function processFollow( - address follower, - uint256 profileId, - bytes calldata data + uint256, + address, + address, + uint256, + bytes calldata ) external view override onlyHub { revert Errors.FollowInvalid(); } diff --git a/contracts/core/modules/reference/FollowerOnlyReferenceModule.sol b/contracts/core/modules/reference/FollowerOnlyReferenceModule.sol index 9effa04..2dcb8dc 100644 --- a/contracts/core/modules/reference/FollowerOnlyReferenceModule.sol +++ b/contracts/core/modules/reference/FollowerOnlyReferenceModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IReferenceModule} from '../../../interfaces/IReferenceModule.sol'; import {ModuleBase} from '../ModuleBase.sol'; @@ -21,9 +21,10 @@ contract FollowerOnlyReferenceModule is FollowValidationModuleBase, IReferenceMo * @dev There is nothing needed at initialization. */ function initializeReferenceModule( - uint256 profileId, - uint256 pubId, - bytes calldata data + uint256, + address, + uint256, + bytes calldata ) external pure override returns (bytes memory) { return new bytes(0); } @@ -35,24 +36,26 @@ contract FollowerOnlyReferenceModule is FollowValidationModuleBase, IReferenceMo */ function processComment( uint256 profileId, + address, uint256 profileIdPointed, - uint256 pubIdPointed, - bytes calldata data + uint256, + bytes calldata ) external view override { address commentCreator = IERC721(HUB).ownerOf(profileId); _checkFollowValidity(profileIdPointed, commentCreator); } /** - * @notice Validates that the commenting profile's owner is a follower. + * @notice Validates that the mirroring profile's owner is a follower. * * NOTE: We don't need to care what the pointed publication is in this context. */ function processMirror( uint256 profileId, + address, uint256 profileIdPointed, - uint256 pubIdPointed, - bytes calldata data + uint256, + bytes calldata ) external view override { address mirrorCreator = IERC721(HUB).ownerOf(profileId); _checkFollowValidity(profileIdPointed, mirrorCreator); diff --git a/contracts/core/storage/LensHubStorage.sol b/contracts/core/storage/LensHubStorage.sol index 980c123..c378e32 100644 --- a/contracts/core/storage/LensHubStorage.sol +++ b/contracts/core/storage/LensHubStorage.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from '../../libraries/DataTypes.sol'; @@ -13,60 +13,24 @@ import {DataTypes} from '../../libraries/DataTypes.sol'; * storage variables should be done solely at the bottom of this contract. */ abstract contract LensHubStorage { - bytes32 internal constant SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH = - keccak256( - 'SetDefaultProfileWithSig(address wallet,uint256 profileId,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH = - keccak256( - 'SetFollowModuleWithSig(uint256 profileId,address followModule,bytes followModuleInitData,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant SET_FOLLOW_NFT_URI_WITH_SIG_TYPEHASH = - keccak256( - 'SetFollowNFTURIWithSig(uint256 profileId,string followNFTURI,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant SET_DISPATCHER_WITH_SIG_TYPEHASH = - keccak256( - 'SetDispatcherWithSig(uint256 profileId,address dispatcher,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH = - keccak256( - 'SetProfileImageURIWithSig(uint256 profileId,string imageURI,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant POST_WITH_SIG_TYPEHASH = - keccak256( - 'PostWithSig(uint256 profileId,string contentURI,address collectModule,bytes collectModuleInitData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant COMMENT_WITH_SIG_TYPEHASH = - keccak256( - 'CommentWithSig(uint256 profileId,string contentURI,uint256 profileIdPointed,uint256 pubIdPointed,bytes referenceModuleData,address collectModule,bytes collectModuleInitData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant MIRROR_WITH_SIG_TYPEHASH = - keccak256( - 'MirrorWithSig(uint256 profileId,uint256 profileIdPointed,uint256 pubIdPointed,bytes referenceModuleData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant FOLLOW_WITH_SIG_TYPEHASH = - keccak256( - 'FollowWithSig(uint256[] profileIds,bytes[] datas,uint256 nonce,uint256 deadline)' - ); - bytes32 internal constant COLLECT_WITH_SIG_TYPEHASH = - keccak256( - 'CollectWithSig(uint256 profileId,uint256 pubId,bytes data,uint256 nonce,uint256 deadline)' - ); + mapping(address => bool) internal _profileCreatorWhitelisted; // Slot 13 + mapping(address => bool) internal _followModuleWhitelisted; // Slot 14 + mapping(address => bool) internal _collectModuleWhitelisted; // Slot 15 + mapping(address => bool) internal _referenceModuleWhitelisted; // Slot 16 - mapping(address => bool) internal _profileCreatorWhitelisted; - mapping(address => bool) internal _followModuleWhitelisted; - mapping(address => bool) internal _collectModuleWhitelisted; - mapping(address => bool) internal _referenceModuleWhitelisted; + mapping(uint256 => address) internal _dispatcherByProfile; // Slot 17 + mapping(bytes32 => uint256) internal _profileIdByHandleHash; // Slot 18 + mapping(uint256 => DataTypes.ProfileStruct) internal _profileById; // Slot 19 + mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) internal _pubByIdByProfile; // Slot 20 - mapping(uint256 => address) internal _dispatcherByProfile; - mapping(bytes32 => uint256) internal _profileIdByHandleHash; - mapping(uint256 => DataTypes.ProfileStruct) internal _profileById; - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) internal _pubByIdByProfile; + mapping(address => uint256) internal _defaultProfileByAddress; // Slot 21 - mapping(address => uint256) internal _defaultProfileByAddress; + uint256 internal _profileCounter; // Slot 22 - this is different to TotalSupply, as TotalSupply is decreased when the Profile is burned + address internal _governance; // Slot 23 + address internal _emergencyAdmin; // Slot 24 - uint256 internal _profileCounter; - address internal _governance; - address internal _emergencyAdmin; + // Slots introduced by Lens V2 upgrade. + mapping(address => mapping(address => bool)) internal _delegatedExecutorApproval; // Slot 25 + mapping(uint256 => string) internal _metadataByProfile; // Slot 26 + mapping(uint256 => mapping(uint256 => bool)) internal _blockedStatus; // Slot 27, _blockedStatus[byProfile][profile] } diff --git a/contracts/interfaces/ICollectModule.sol b/contracts/interfaces/ICollectModule.sol index f490942..6940530 100644 --- a/contracts/interfaces/ICollectModule.sol +++ b/contracts/interfaces/ICollectModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title ICollectModule @@ -13,6 +13,7 @@ interface ICollectModule { * @notice Initializes data for a given publication being published. This can only be called by the hub. * * @param profileId The token ID of the profile publishing the publication. + * @param executor The owner or an approved delegated executor. * @param pubId The associated publication's LensHub publication ID. * @param data Arbitrary data __passed from the user!__ to be decoded. * @@ -21,6 +22,7 @@ interface ICollectModule { */ function initializePublicationCollectModule( uint256 profileId, + address executor, uint256 pubId, bytes calldata data ) external returns (bytes memory); @@ -29,15 +31,19 @@ interface ICollectModule { * @notice Processes a collect action for a given publication, this can only be called by the hub. * * @param referrerProfileId The LensHub profile token ID of the referrer's profile (only different in case of mirrors). - * @param collector The collector address. - * @param profileId The token ID of the profile associated with the publication being collected. + * @param collectorProfileId The LensHub profile token ID of the collector's profile. + * @param collectorProfileOwner The collector address. + * @param executor The collector or an approved delegated executor. + * @param publisherProfileId The token ID of the profile associated with the publication being collected. * @param pubId The LensHub publication ID associated with the publication being collected. * @param data Arbitrary data __passed from the collector!__ to be decoded. */ function processCollect( uint256 referrerProfileId, - address collector, - uint256 profileId, + uint256 collectorProfileId, + address collectorProfileOwner, + address executor, + uint256 publisherProfileId, uint256 pubId, bytes calldata data ) external; diff --git a/contracts/interfaces/ICollectNFT.sol b/contracts/interfaces/ICollectNFT.sol index 1f37ded..dde2bfd 100644 --- a/contracts/interfaces/ICollectNFT.sol +++ b/contracts/interfaces/ICollectNFT.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title ICollectNFT diff --git a/contracts/interfaces/IDeprecatedCollectModule.sol b/contracts/interfaces/IDeprecatedCollectModule.sol new file mode 100644 index 0000000..abc5716 --- /dev/null +++ b/contracts/interfaces/IDeprecatedCollectModule.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +/** + * @title ICollectModule + * @author Lens Protocol + * + * @notice This is the deprecated interface for previously Lens-compatible CollectModules. + */ +interface IDeprecatedCollectModule { + /** + * @notice Initializes data for a given publication being published. This can only be called by the hub. + * + * @param profileId The token ID of the profile publishing the publication. + * @param pubId The associated publication's LensHub publication ID. + * @param data Arbitrary data __passed from the user!__ to be decoded. + * + * @return bytes An abi encoded byte array encapsulating the execution's state changes. This will be emitted by the + * hub alongside the collect module's address and should be consumed by front ends. + */ + function initializePublicationCollectModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external returns (bytes memory); + + /** + * @notice Processes a collect action for a given publication, this can only be called by the hub. + * + * @param referrerProfileId The LensHub profile token ID of the referrer's profile (only different in case of mirrors). + * @param collector The collector address. + * @param profileId The token ID of the profile associated with the publication being collected. + * @param pubId The LensHub publication ID associated with the publication being collected. + * @param data Arbitrary data __passed from the collector!__ to be decoded. + */ + function processCollect( + uint256 referrerProfileId, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external; +} diff --git a/contracts/interfaces/IDeprecatedFollowModule.sol b/contracts/interfaces/IDeprecatedFollowModule.sol new file mode 100644 index 0000000..417e237 --- /dev/null +++ b/contracts/interfaces/IDeprecatedFollowModule.sol @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +/** + * @title IFollowModule + * @author Lens Protocol + * + * @notice This is the deprecated interface for previously Lens-compatible FollowModules. + */ +interface IDeprecatedFollowModule { + /** + * @notice Initializes a follow module for a given Lens profile. This can only be called by the hub contract. + * + * @param profileId The token ID of the profile to initialize this follow module for. + * @param data Arbitrary data passed by the profile creator. + * + * @return bytes The encoded data to emit in the hub. + */ + function initializeFollowModule( + uint256 profileId, + bytes calldata data + ) external returns (bytes memory); + + /** + * @notice Processes a given follow, this can only be called from the LensHub contract. + * + * @param follower The follower address. + * @param profileId The token ID of the profile being followed. + * @param data Arbitrary data passed by the follower. + */ + function processFollow( + address follower, + uint256 profileId, + bytes calldata data + ) external; + + /** + * @notice This is a transfer hook that is called upon follow NFT transfer in `beforeTokenTransfer. This can + * only be called from the LensHub contract. + * + * NOTE: Special care needs to be taken here: It is possible that follow NFTs were issued before this module + * was initialized if the profile's follow module was previously different. This transfer hook should take this + * into consideration, especially when the module holds state associated with individual follow NFTs. + * + * @param profileId The token ID of the profile associated with the follow NFT being transferred. + * @param from The address sending the follow NFT. + * @param to The address receiving the follow NFT. + * @param followNFTTokenId The token ID of the follow NFT being transferred. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external; + + /** + * @notice This is a helper function that could be used in conjunction with specific collect modules. + * + * NOTE: This function IS meant to replace a check on follower NFT ownership. + * + * NOTE: It is assumed that not all collect modules are aware of the token ID to pass. In these cases, + * this should receive a `followNFTTokenId` of 0, which is impossible regardless. + * + * One example of a use case for this would be a subscription-based following system: + * 1. The collect module: + * - Decodes a follower NFT token ID from user-passed data. + * - Fetches the follow module from the hub. + * - Calls `isFollowing` passing the profile ID, follower & follower token ID and checks it returned true. + * 2. The follow module: + * - Validates the subscription status for that given NFT, reverting on an invalid subscription. + * + * @param profileId The token ID of the profile to validate the follow for. + * @param follower The follower address to validate the follow for. + * @param followNFTTokenId The followNFT token ID to validate the follow for. + * + * @return true if the given address is following the given profile ID, false otherwise. + */ + function isFollowing( + uint256 profileId, + address follower, + uint256 followNFTTokenId + ) external view returns (bool); +} diff --git a/contracts/interfaces/IDeprecatedReferenceModule.sol b/contracts/interfaces/IDeprecatedReferenceModule.sol new file mode 100644 index 0000000..a501099 --- /dev/null +++ b/contracts/interfaces/IDeprecatedReferenceModule.sol @@ -0,0 +1,57 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +/** + * @title IReferenceModule + * @author Lens Protocol + * + * @notice This is the deprecated interface for previously Lens-compatible ReferenceModules. + */ +interface IDeprecatedReferenceModule { + /** + * @notice Initializes data for a given publication being published. This can only be called by the hub. + * + * @param profileId The token ID of the profile publishing the publication. + * @param pubId The associated publication's LensHub publication ID. + * @param data Arbitrary data passed from the user to be decoded. + * + * @return bytes An abi encoded byte array encapsulating the execution's state changes. This will be emitted by the + * hub alongside the collect module's address and should be consumed by front ends. + */ + function initializeReferenceModule( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external returns (bytes memory); + + /** + * @notice Processes a comment action referencing a given publication. This can only be called by the hub. + * + * @param profileId The token ID of the profile associated with the publication being published. + * @param profileIdPointed The profile ID of the profile associated the publication being referenced. + * @param pubIdPointed The publication ID of the publication being referenced. + * @param data Arbitrary data __passed from the commenter!__ to be decoded. + */ + function processComment( + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata data + ) external; + + /** + * @notice Processes a mirror action referencing a given publication. This can only be called by the hub. + * + * @param profileId The token ID of the profile associated with the publication being published. + * @param profileIdPointed The profile ID of the profile associated the publication being referenced. + * @param pubIdPointed The publication ID of the publication being referenced. + * @param data Arbitrary data __passed from the mirrorer!__ to be decoded. + */ + function processMirror( + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata data + ) external; +} diff --git a/contracts/interfaces/IEIP1271Implementer.sol b/contracts/interfaces/IEIP1271Implementer.sol new file mode 100644 index 0000000..0c4be69 --- /dev/null +++ b/contracts/interfaces/IEIP1271Implementer.sol @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +interface IEIP1271Implementer { + function isValidSignature(bytes32 _hash, bytes memory _signature) + external + view + returns (bytes4); +} diff --git a/contracts/core/base/IERC721Time.sol b/contracts/interfaces/IERC721Time.sol similarity index 96% rename from contracts/core/base/IERC721Time.sol rename to contracts/interfaces/IERC721Time.sol index df84f4f..c83bd1e 100644 --- a/contracts/core/base/IERC721Time.sol +++ b/contracts/interfaces/IERC721Time.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; -import '@openzeppelin/contracts/token/ERC721/IERC721.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; /** * @title IERC721Time diff --git a/contracts/interfaces/IFollowModule.sol b/contracts/interfaces/IFollowModule.sol index c6f636c..9344557 100644 --- a/contracts/interfaces/IFollowModule.sol +++ b/contracts/interfaces/IFollowModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title IFollowModule @@ -13,72 +13,32 @@ interface IFollowModule { * @notice Initializes a follow module for a given Lens profile. This can only be called by the hub contract. * * @param profileId The token ID of the profile to initialize this follow module for. + * @param executor The owner or an approved delegated executor. * @param data Arbitrary data passed by the profile creator. * * @return bytes The encoded data to emit in the hub. */ - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - returns (bytes memory); + function initializeFollowModule( + uint256 profileId, + address executor, + bytes calldata data + ) external returns (bytes memory); /** * @notice Processes a given follow, this can only be called from the LensHub contract. * - * @param follower The follower address. + * @param followerProfileId The LensHub profile token ID of the follower's profile (currently unused, preemptive interface upgrade). + * @param followTokenId The ID of the follow token used to follow. Zero if a new one was minted, in this case, the follow ID assigned + * can be queried from the Follow NFT collection if needed. + * @param executor The follower or an approved delegated executor. * @param profileId The token ID of the profile being followed. * @param data Arbitrary data passed by the follower. */ function processFollow( - address follower, + uint256 followerProfileId, + uint256 followTokenId, + address executor, uint256 profileId, bytes calldata data ) external; - - /** - * @notice This is a transfer hook that is called upon follow NFT transfer in `beforeTokenTransfer. This can - * only be called from the LensHub contract. - * - * NOTE: Special care needs to be taken here: It is possible that follow NFTs were issued before this module - * was initialized if the profile's follow module was previously different. This transfer hook should take this - * into consideration, especially when the module holds state associated with individual follow NFTs. - * - * @param profileId The token ID of the profile associated with the follow NFT being transferred. - * @param from The address sending the follow NFT. - * @param to The address receiving the follow NFT. - * @param followNFTTokenId The token ID of the follow NFT being transferred. - */ - function followModuleTransferHook( - uint256 profileId, - address from, - address to, - uint256 followNFTTokenId - ) external; - - /** - * @notice This is a helper function that could be used in conjunction with specific collect modules. - * - * NOTE: This function IS meant to replace a check on follower NFT ownership. - * - * NOTE: It is assumed that not all collect modules are aware of the token ID to pass. In these cases, - * this should receive a `followNFTTokenId` of 0, which is impossible regardless. - * - * One example of a use case for this would be a subscription-based following system: - * 1. The collect module: - * - Decodes a follower NFT token ID from user-passed data. - * - Fetches the follow module from the hub. - * - Calls `isFollowing` passing the profile ID, follower & follower token ID and checks it returned true. - * 2. The follow module: - * - Validates the subscription status for that given NFT, reverting on an invalid subscription. - * - * @param profileId The token ID of the profile to validate the follow for. - * @param follower The follower address to validate the follow for. - * @param followNFTTokenId The followNFT token ID to validate the follow for. - * - * @return true if the given address is following the given profile ID, false otherwise. - */ - function isFollowing( - uint256 profileId, - address follower, - uint256 followNFTTokenId - ) external view returns (bool); } diff --git a/contracts/interfaces/IFollowModuleLegacy.sol b/contracts/interfaces/IFollowModuleLegacy.sol new file mode 100644 index 0000000..b947ac1 --- /dev/null +++ b/contracts/interfaces/IFollowModuleLegacy.sol @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +/** + * @title IFollowModuleLegacy + * @author Lens Protocol + * + * @notice This is the standard interface for all Lens-compatible FollowModules. + */ +interface IFollowModuleLegacy { + /** + * @notice Initializes a follow module for a given Lens profile. This can only be called by the hub contract. + * + * @param profileId The token ID of the profile to initialize this follow module for. + * @param executor The owner or an approved delegated executor. + * @param data Arbitrary data passed by the profile creator. + * + * @return bytes The encoded data to emit in the hub. + */ + function initializeFollowModule( + uint256 profileId, + address executor, + bytes calldata data + ) external returns (bytes memory); + + /** + * @notice Processes a given follow, this can only be called from the LensHub contract. + * + * @param followerProfileId The LensHub profile token ID of the follower's profile (currently unused, preemptive interface upgrade). + * @param follower The follower address. + * @param executor The follower or an approved delegated executor. + * @param profileId The token ID of the profile being followed. + * @param data Arbitrary data passed by the follower. + */ + function processFollow( + uint256 followerProfileId, + address follower, + address executor, + uint256 profileId, + bytes calldata data + ) external; + + /** + * @notice This is a transfer hook that is called upon follow NFT transfer in `beforeTokenTransfer. This can + * only be called from the LensHub contract. + * + * NOTE: Special care needs to be taken here: It is possible that follow NFTs were issued before this module + * was initialized if the profile's follow module was previously different. This transfer hook should take this + * into consideration, especially when the module holds state associated with individual follow NFTs. + * + * @param profileId The token ID of the profile associated with the follow NFT being transferred. + * @param from The address sending the follow NFT. + * @param to The address receiving the follow NFT. + * @param followNFTTokenId The token ID of the follow NFT being transferred. + */ + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external; + + /** + * @notice This is a helper function that could be used in conjunction with specific collect modules. + * + * NOTE: This function IS meant to replace a check on follower NFT ownership. + * + * NOTE: It is assumed that not all collect modules are aware of the token ID to pass. In these cases, + * this should receive a `followNFTTokenId` of 0, which is impossible regardless. + * + * One example of a use case for this would be a subscription-based following system: + * 1. The collect module: + * - Decodes a follower NFT token ID from user-passed data. + * - Fetches the follow module from the hub. + * - Calls `isFollowing` passing the profile ID, follower & follower token ID and checks it returned true. + * 2. The follow module: + * - Validates the subscription status for that given NFT, reverting on an invalid subscription. + * + * @param followerProfileId The LensHub profile token ID of the follower's profile (currently unused, preemptive interface upgrade). + * @param profileId The token ID of the profile to validate the follow for. + * @param follower The follower address to validate the follow for. + * @param followNFTTokenId The followNFT token ID to validate the follow for. + * + * @return true if the given address is following the given profile ID, false otherwise. + */ + function isFollowing( + uint256 followerProfileId, + uint256 profileId, + address follower, + uint256 followNFTTokenId + ) external view returns (bool); +} diff --git a/contracts/interfaces/IFollowNFT.sol b/contracts/interfaces/IFollowNFT.sol index b904976..f911207 100644 --- a/contracts/interfaces/IFollowNFT.sol +++ b/contracts/interfaces/IFollowNFT.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from '../libraries/DataTypes.sol'; @@ -11,60 +11,183 @@ import {DataTypes} from '../libraries/DataTypes.sol'; * @notice This is the interface for the FollowNFT contract, which is cloned upon the first follow for any profile. */ interface IFollowNFT { + error AlreadyFollowing(); + error NotFollowing(); + error FollowTokenDoesNotExist(); + error AlreadyWrapped(); + error OnlyWrappedFollowTokens(); + error DoesNotHavePermissions(); + /** - * @notice Initializes the follow NFT, setting the hub as the privileged minter and storing the associated profile ID. + * @notice A struct containing token follow-related data. * - * @param profileId The token ID of the profile in the hub associated with this followNFT, used for transfer hooks. + * @param followerProfileId The ID of the profile using the token to follow. + * @param originalFollowTimestamp The timestamp of the first follow performed with the token. + * @param followTimestamp The timestamp of the current follow, if a profile is using the token to follow. + * @param profileIdAllowedToRecover The ID of the profile allowed to recover the follow ID, if any. + */ + struct FollowData { + uint160 followerProfileId; + uint48 originalFollowTimestamp; + uint48 followTimestamp; + uint256 profileIdAllowedToRecover; + } + + /** + * @notice Initializes the follow NFT. + * + * @dev Sets the hub as priviliged sender, the targeted profile, and the token royalties. + * + * @param profileId The ID of the profile targeted by the follow tokens minted by this collection. */ function initialize(uint256 profileId) external; /** - * @notice Mints a follow NFT to the specified address. This can only be called by the hub, and is called - * upon follow. + * @notice Makes the passed profile to follow the profile targeted in this contract. * - * @param to The address to mint the NFT to. + * @dev This must be only callable by the LensHub contract. * - * @return uint256 An interger representing the minted token ID. + * @param followerProfileId The ID of the profile acting as the follower. + * @param executor The address executing the operation, which is the signer in case of using meta-transactions or + * the sender otherwise. + * @param followTokenId The ID of the follow token to be used for this follow operation. Zero if a new follow token + * should be minted. + * + * @return uint256 The ID of the token used to follow. */ - function mint(address to) external returns (uint256); + function follow( + uint256 followerProfileId, + address executor, + uint256 followTokenId + ) external returns (uint256); /** - * @notice Delegates the caller's governance power to the given delegatee address. + * @notice Makes the passed profile to unfollow the profile targeted in this contract. * - * @param delegatee The delegatee address to delegate governance power to. + * @dev This must be only callable by the LensHub contract. + * + * @param unfollowerProfileId The ID of the profile that is perfrorming the unfollow operation. + * @param executor The address executing the operation, which is the signer in case of using meta-transactions or + * the sender otherwise. */ - function delegate(address delegatee) external; + function unfollow(uint256 unfollowerProfileId, address executor) external; /** - * @notice Delegates the delegator's governance power via meta-tx to the given delegatee address. + * @notice Removes the follower from the given follow NFT. * - * @param delegator The delegator address, who is the signer. - * @param delegatee The delegatee address, who is receiving the governance power delegation. - * @param sig The EIP712Signature struct containing the necessary parameters to recover the delegator's signature. + * @dev It can only be called over wrapped tokens, by their owner or an approved-for-all address. + * + * @param followTokenId The ID of the follow token to remove the follower from. */ - function delegateBySig( - address delegator, - address delegatee, - DataTypes.EIP712Signature calldata sig - ) external; + function removeFollower(uint256 followTokenId) external; /** - * @notice Returns the governance power for a given user at a specified block number. + * @notice Approves the given profile to follow with the given wrapped token. * - * @param user The user to query governance power for. - * @param blockNumber The block number to query the user's governance power at. + * @dev It approves setting a follower on the given wrapped follow token, which lets the follow token owner to allow + * a profile to follow with his token without losing its ownership. This approval is cleared on transfers, as well + * as when unwrapping. * - * @return uint256 The power of the given user at the given block number. + * @param approvedProfileId The ID of the profile approved to follow with the given token. + * @param followTokenId The ID of the follow token to be approved for the given profile. */ - function getPowerByBlockNumber(address user, uint256 blockNumber) external returns (uint256); + function approveFollow(uint256 approvedProfileId, uint256 followTokenId) external; /** - * @notice Returns the total delegated supply at a specified block number. This is the sum of all - * current available voting power at a given block. + * @notice Unties the follow token from the follower's profile one, and wraps it into the ERC-721 untied follow + * tokens collection. Untied follow tokens will NOT be automatically transferred with their follower profile. * - * @param blockNumber The block number to query the delegated supply at. - * - * @return uint256 The delegated supply at the given block number. + * @param followTokenId The ID of the follow token to untie and wrap. */ - function getDelegatedSupplyByBlockNumber(uint256 blockNumber) external returns (uint256); + function wrap(uint256 followTokenId) external; + + /** + * @notice Unwraps the follow token from the ERC-721 untied follow tokens collection, and ties it to the follower's + * profile token. Tokens that are tied to the follower profile will be automatically transferred with it. + * + * @param followTokenId The ID of the follow token to unwrap and tie to its follower. + */ + function unwrap(uint256 followTokenId) external; + + /** + * @notice Processes logic when the given profile is being blocked. If it was following the targeted profile, + * this will make it to unfollow. + * + * @dev This must be only callable by the LensHub contract. + * + * @param followerProfileId The ID of the follow token to unwrap and tie. + */ + function processBlock(uint256 followerProfileId) external; + + /** + * @notice Gets the ID of the profile following with the given follow token. + * + * @param followTokenId The ID of the follow token whose follower should be queried. + * + * @return uint256 The ID of the profile following with the given token, zero if it is not being used to follow. + */ + function getFollowerProfileId(uint256 followTokenId) external view returns (uint256); + + /** + * @notice Gets the original follow timestamp of the given follow token. + * + * @param followTokenId The ID of the follow token whose original follow timestamp should be queried. + * + * @return uint256 The timestamp of the first follow performed with the token, zero if was not used to follow yet. + */ + function getOriginalFollowTimestamp(uint256 followTokenId) external view returns (uint256); + + /** + * @notice Gets the current follow timestamp of the given follow token. + * + * @param followTokenId The ID of the follow token whose follow timestamp should be queried. + * + * @return uint256 The timestamp of the current follow of the token, zero if it is not being used to follow. + */ + function getFollowTimestamp(uint256 followTokenId) external view returns (uint256); + + /** + * @notice Gets the ID of the profile allowed to recover the given follow token. + * + * @param followTokenId The ID of the follow token whose allowed profile to recover should be queried. + * + * @return uint256 The ID of the profile allowed to recover the given follow token, zero if none of them is allowed. + */ + function getProfileIdAllowedToRecover(uint256 followTokenId) external view returns (uint256); + + /** + * @notice Gets the follow data of the given follow token. + * + * @param followTokenId The ID of the follow token whose follow data should be queried. + * + * @return FollowData The token data associated with the given follow token. + */ + function getFollowData(uint256 followTokenId) external view returns (FollowData memory); + + /** + * @notice Tells if the given profile is following the profile targeted in this contract. + * + * @param followerProfileId The ID of the profile whose following state should be queried. + * + * @return uint256 The ID of the profile set as follower in the given token, zero if it is not being used to follow. + */ + function isFollowing(uint256 followerProfileId) external view returns (bool); + + /** + * @notice Gets the ID of the token being used to follow by the given follower. + * + * @param followerProfileId The ID of the profile whose follow ID should be queried. + * + * @return uint256 The ID of the token being used to follow by the given follower, zero if he is not following. + */ + function getFollowTokenId(uint256 followerProfileId) external view returns (uint256); + + /** + * @notice Gets the ID of the profile approved to follow with the given token. + * + * @param followTokenId The ID of the token whose approved to follow should be queried. + * + * @return uint256 The ID of the profile approved to follow with the given token, zero if none of them is approved. + */ + function getFollowApproved(uint256 followTokenId) external view returns (uint256); } diff --git a/contracts/interfaces/ILensHub.sol b/contracts/interfaces/ILensHub.sol index adea840..ae2d24d 100644 --- a/contracts/interfaces/ILensHub.sol +++ b/contracts/interfaces/ILensHub.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from '../libraries/DataTypes.sol'; @@ -96,7 +96,6 @@ interface ILensHub { * * @param vars A CreateProfileData struct containing the following params: * to: The address receiving the profile. - * handle: The handle to set for the profile, must be unique and non-empty. * imageURI: The URI to set for the profile image. * followModule: The follow module to use, can be the zero address. * followModuleInitData: The follow module initialization data, if any. @@ -104,14 +103,17 @@ interface ILensHub { function createProfile(DataTypes.CreateProfileData calldata vars) external returns (uint256); /** - * @notice Sets the mapping between wallet and its main profile identity. + * @notice Sets the mapping between wallet and its main profile identity. Must be called either by the wallet or a + * delegated executor. * + * @param onBehalfOf The address to set the default profile on behalf of. * @param profileId The token ID of the profile to set as the main profile identity. */ - function setDefaultProfile(uint256 profileId) external; + function setDefaultProfile(address onBehalfOf, uint256 profileId) external; /** - * @notice Sets the mapping between wallet and its main profile identity via signature with the specified parameters. + * @notice Sets the mapping between wallet and its main profile identity via signature with the specified parameters. The + * signer must either be the profile owner or a delegated executor. * * @param vars A SetDefaultProfileWithSigData struct, including the regular parameters and an EIP712Signature struct. */ @@ -119,7 +121,25 @@ interface ILensHub { external; /** - * @notice Sets a profile's follow module, must be called by the profile owner. + * @notice Sets the metadata URI for the given profile. Must be called either from the profile owner, a delegated + * executor, or the profile's dispatcher. + * + * @param profileId The token ID of the profile to set the metadata URI for. + * @param metadataURI The metadata URI to set for the given profile. + */ + function setProfileMetadataURI(uint256 profileId, string calldata metadataURI) external; + + /** + * @notice Sets the metadata URI via signature for the given profile with the specified parameters. The signer must + * either be the profile owner or a delegated executor. + * + * @param vars A SetProfileMetadataURIWithSigData struct, including the regular parameters and an EIP712Signature struct. + */ + function setProfileMetadataURIWithSig(DataTypes.SetProfileMetadataURIWithSigData calldata vars) + external; + + /** + * @notice Sets the follow module for the given profile. Must be called by the profile owner. * * @param profileId The token ID of the profile to set the follow module for. * @param followModule The follow module to set for the given profile, must be whitelisted. @@ -132,7 +152,8 @@ interface ILensHub { ) external; /** - * @notice Sets a profile's follow module via signature with the specified parameters. + * @notice Sets the follow module via signature for the given profile with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A SetFollowModuleWithSigData struct, including the regular parameters and an EIP712Signature struct. */ @@ -154,7 +175,25 @@ interface ILensHub { function setDispatcherWithSig(DataTypes.SetDispatcherWithSigData calldata vars) external; /** - * @notice Sets a profile's URI, which is reflected in the `tokenURI()` function. + * @notice Sets the approval for a delegated executor to act on behalf of the caller. + * + * @param executor The executor to set the approval for. + * @param approved The approval to set. + */ + function setDelegatedExecutorApproval(address executor, bool approved) external; + + /** + * @notice Sets the approval for a delegated executor to act on behalf of a given signer. + * + * @param vars A SetDelegatedExecutorApprovalWithSigData struct, including the regular parameters and an EIP712Signature + * struct. + */ + function setDelegatedExecutorApprovalWithSig( + DataTypes.SetDelegatedExecutorApprovalWithSigData calldata vars + ) external; + + /** + * @notice Sets a profile's image URI, which is reflected in the `tokenURI()` function. * * @param profileId The token ID of the profile of the profile to set the URI for. * @param imageURI The URI to set for the given profile. @@ -162,7 +201,8 @@ interface ILensHub { function setProfileImageURI(uint256 profileId, string calldata imageURI) external; /** - * @notice Sets a profile's URI via signature with the specified parameters. + * @notice Sets the image URI via signature for the given profile with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A SetProfileImageURIWithSigData struct, including the regular parameters and an EIP712Signature struct. */ @@ -178,7 +218,8 @@ interface ILensHub { function setFollowNFTURI(uint256 profileId, string calldata followNFTURI) external; /** - * @notice Sets a followNFT URI via signature with the specified parameters. + * @notice Sets a followNFT URI via signature for the given profile with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A SetFollowNFTURIWithSigData struct, including the regular parameters and an EIP712Signature struct. */ @@ -194,7 +235,8 @@ interface ILensHub { function post(DataTypes.PostData calldata vars) external returns (uint256); /** - * @notice Publishes a post to a given profile via signature with the specified parameters. + * @notice Publishes a post to a given profile via signature with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A PostWithSigData struct containing the regular parameters and an EIP712Signature struct. * @@ -212,7 +254,8 @@ interface ILensHub { function comment(DataTypes.CommentData calldata vars) external returns (uint256); /** - * @notice Publishes a comment to a given profile via signature with the specified parameters. + * @notice Publishes a comment to a given profile via signature with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A CommentWithSigData struct containing the regular parameters and an EIP712Signature struct. * @@ -230,7 +273,8 @@ interface ILensHub { function mirror(DataTypes.MirrorData calldata vars) external returns (uint256); /** - * @notice Publishes a mirror to a given profile via signature with the specified parameters. + * @notice Publishes a mirror to a given profile via signature with the specified parameters. The signer must + * either be the profile owner or a delegated executor. * * @param vars A MirrorWithSigData struct containing the regular parameters and an EIP712Signature struct. * @@ -239,48 +283,101 @@ interface ILensHub { function mirrorWithSig(DataTypes.MirrorWithSigData calldata vars) external returns (uint256); /** - * @notice Follows the given profiles, executing each profile's follow module logic (if any) and minting followNFTs to the caller. + * @notice Follows the given profiles, executing each profile's follow module logic (if any). * - * NOTE: Both the `profileIds` and `datas` arrays must be of the same length, regardless if the profiles do not have a follow module set. + * @dev Both the `idsOfProfilesToFollow`, `followTokenIds`, and `datas` arrays must be of the same length, + * regardless if the profiles do not have a follow module set. * - * @param profileIds The token ID array of the profiles to follow. + * @param followerProfileId The ID of the profile the follows are being executed for. + * @param idsOfProfilesToFollow The array of IDs of profiles to follow. + * @param followTokenIds The array of follow token IDs to use for each follow. * @param datas The arbitrary data array to pass to the follow module for each profile if needed. * - * @return uint256[] An array of integers representing the minted follow NFTs token IDs. + * @return uint256[] An array follow token IDs used for each follow operation. */ - function follow(uint256[] calldata profileIds, bytes[] calldata datas) - external - returns (uint256[] memory); + function follow( + uint256 followerProfileId, + uint256[] calldata idsOfProfilesToFollow, + uint256[] calldata followTokenIds, + bytes[] calldata datas + ) external returns (uint256[] memory); /** - * @notice Follows a given profile via signature with the specified parameters. + * @notice Follows the given profiles via signature with the specified parameters. The signer must either be the + * follower or a delegated executor. * - * @param vars A FollowWithSigData struct containing the regular parameters as well as the signing follower's address - * and an EIP712Signature struct. + * @param vars A FollowWithSigData struct containing the regular parameters as well as the signing follower's + * address and an EIP712Signature struct. * - * @return uint256[] An array of integers representing the minted follow NFTs token IDs. + * @return uint256[] An array follow token IDs used for each follow operation. */ function followWithSig(DataTypes.FollowWithSigData calldata vars) external returns (uint256[] memory); + /** + * @notice Unfollows the given profiles. + * + * @param unfollowerProfileId The ID of the profile the unfollows are being executed for. + * @param idsOfProfilesToUnfollow The array of IDs of profiles to unfollow. + */ + function unfollow(uint256 unfollowerProfileId, uint256[] calldata idsOfProfilesToUnfollow) + external; + + /** + * @notice Unfollows the given profiles via signature with the specified parameters. The signer must either be the + * unfollower or a delegated executor. + * + * @param vars An UnollowWithSigData struct containing the regular parameters as well as the signing unfollower's + * address and an EIP712Signature struct. + */ + function unfollowWithSig(DataTypes.UnfollowWithSigData calldata vars) external; + + /** + * @notice Sets the block status for the given profiles. Changing a profile's block status to `true` (i.e. blocked), + * when it was following, will make it unfollow. + * + * @dev Both the `idsOfProfilesToSetBlockStatus` and `blockStatus` arrays must be of the same length. + * + * @param byProfileId The ID of the profile the block status sets are being executed for. + * @param idsOfProfilesToSetBlockStatus The array of IDs of profiles to set block status. + * @param blockStatus The array of block status to use for each setting. + */ + function setBlockStatus( + uint256 byProfileId, + uint256[] calldata idsOfProfilesToSetBlockStatus, + bool[] calldata blockStatus + ) external; + + /** + * @notice Blocks the given profiles via signature with the specified parameters. The signer must either be the + * blocker or a delegated executor. + * + * @param vars An SetBlockStatusWithSigData struct containing the regular parameters as well as the signing + * blocker's address and an EIP712Signature struct. + */ + function setBlockStatusWithSig(DataTypes.SetBlockStatusWithSigData calldata vars) external; + /** * @notice Collects a given publication, executing collect module logic and minting a collectNFT to the caller. * - * @param profileId The token ID of the profile that published the publication to collect. + * @param collectorProfileId The ID of the profile the collect is being executed from. + * @param publisherProfileId The token ID of the profile that published the publication to collect. * @param pubId The publication to collect's publication ID. * @param data The arbitrary data to pass to the collect module if needed. * * @return uint256 An integer representing the minted token ID. */ function collect( - uint256 profileId, + uint256 collectorProfileId, + uint256 publisherProfileId, uint256 pubId, bytes calldata data ) external returns (uint256); /** - * @notice Collects a given publication via signature with the specified parameters. + * @notice Collects a given publication via signature with the specified parameters. The signer must either be the collector + * or a delegated executor. * * @param vars A CollectWithSigData struct containing the regular parameters as well as the collector's address and * an EIP712Signature struct. @@ -290,8 +387,8 @@ interface ILensHub { function collectWithSig(DataTypes.CollectWithSigData calldata vars) external returns (uint256); /** - * @dev Helper function to emit a detailed followNFT transfer event from the hub, to be consumed by frontends to track - * followNFT transfers. + * @dev Helper function to emit a detailed followNFT transfer event from the hub, to be consumed by indexers to + * track followNFT transfers. * * @param profileId The token ID of the profile associated with the followNFT being transferred. * @param followNFTId The followNFT being transferred's token ID. @@ -306,8 +403,8 @@ interface ILensHub { ) external; /** - * @dev Helper function to emit a detailed collectNFT transfer event from the hub, to be consumed by frontends to track - * collectNFT transfers. + * @dev Helper function to emit a detailed collectNFT transfer event from the hub, to be consumed by indexers to + * track collectNFT transfers. * * @param profileId The token ID of the profile associated with the collect NFT being transferred. * @param pubId The publication ID associated with the collect NFT being transferred. @@ -323,10 +420,32 @@ interface ILensHub { address to ) external; + /** + * @dev Helper function to emit an `Unfollowed` event from the hub, to be consumed by indexers to track unfollows. + * + * @param unfollowerProfileId The ID of the profile that executed the unfollow. + * @param idOfProfileUnfollowed The ID of the profile that was unfollowed. + */ + function emitUnfollowedEvent(uint256 unfollowerProfileId, uint256 idOfProfileUnfollowed) + external; + /// ************************ /// *****VIEW FUNCTIONS***** /// ************************ + /** + * @notice Returns whether or not `followerProfileId` is following `followedProfileId`. + * + * @param followerProfileId The ID of the profile whose following state should be queried. + * @param followedProfileId The ID of the profile whose followed state should be queried. + * + * @return bool True if `followerProfileId` is following `followedProfileId`, false otherwise. + */ + function isFollowing(uint256 followerProfileId, uint256 followedProfileId) + external + view + returns (bool); + /** * @notice Returns whether or not a profile creator is whitelisted. * @@ -336,15 +455,6 @@ interface ILensHub { */ function isProfileCreatorWhitelisted(address profileCreator) external view returns (bool); - /** - * @notice Returns default profile for a given wallet address - * - * @param wallet The address to find the default mapping - * - * @return uint256 The default profile id, which will be 0 if not mapped. - */ - function defaultProfile(address wallet) external view returns (uint256); - /** * @notice Returns whether or not a follow module is whitelisted. * @@ -380,23 +490,75 @@ interface ILensHub { function getGovernance() external view returns (address); /** - * @notice Returns the dispatcher associated with a profile. + * @notice Returns whether the given delegated executor is approved to act on behalf of the given + * wallet. + * + * @param wallet The wallet to check the delegated executor approval for. + * @param executor The executor to query the delegated executor approval for. + * + * @return bool True if the executor is approved as a delegated executor to act on behalf of the wallet, + * false otherwise. + */ + function isDelegatedExecutorApproved(address wallet, address executor) + external + view + returns (bool); + + /** + * @notice Returns whether `profile` is blocked by `byProfile`. + * + * @param profileId The ID of the profile whose blocked status should be queried. + * @param byProfileId The ID of the profile whose blocker status should be queried. + * + * @return bool True if `profileId` is blocked by `byProfileId`, false otherwise. + */ + function isBlocked(uint256 profileId, uint256 byProfileId) external view returns (bool); + + /** + * @notice Returns the default profile for a given wallet address + * + * @param wallet The address to find the default mapping + * + * @return uint256 The default profile id, which will be 0 if not mapped. + */ + function getDefaultProfile(address wallet) external view returns (uint256); + + /** + * @notice Returns the metadata URI for a given profile + * + * @param profileId The token ID of the profile to query the metadata URI for. + * + * @return string The metadata URI associated with the given profile. + */ + function getProfileMetadataURI(uint256 profileId) external view returns (string memory); + + /** + * @notice Returns the dispatcher for a given profile. * * @param profileId The token ID of the profile to query the dispatcher for. * - * @return address The dispatcher address associated with the profile. + * @return address The dispatcher address associated with the given profile. */ function getDispatcher(uint256 profileId) external view returns (address); /** * @notice Returns the publication count for a given profile. * - * @param profileId The token ID of the profile to query. + * @param profileId The token ID of the profile to query the publication count for. * - * @return uint256 The number of publications associated with the queried profile. + * @return uint256 The number of publications associated with the given profile. */ function getPubCount(uint256 profileId) external view returns (uint256); + /** + * @notice Returns the image URI for a given profile + * + * @param profileId The token ID of the profile to query the image URI for. + * + * @return string The image URI associated with the given profile. + */ + function getProfileImageURI(uint256 profileId) external view returns (string memory); + /** * @notice Returns the followNFT associated with a given profile, if any. * @@ -421,7 +583,7 @@ interface ILensHub { * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * - * @return address The address of the collectNFT associated with the queried publication. + * @return address The address of the collectNFT associated with the given publication. */ function getCollectNFT(uint256 profileId, uint256 pubId) external view returns (address); @@ -454,15 +616,6 @@ interface ILensHub { */ function getReferenceModule(uint256 profileId, uint256 pubId) external view returns (address); - /** - * @notice Returns the handle associated with a profile. - * - * @param profileId The token ID of the profile to query the handle for. - * - * @return string The handle associated with the profile. - */ - function getHandle(uint256 profileId) external view returns (string memory); - /** * @notice Returns the publication pointer (profileId & pubId) associated with a given publication. * @@ -487,15 +640,6 @@ interface ILensHub { */ function getContentURI(uint256 profileId, uint256 pubId) external view returns (string memory); - /** - * @notice Returns the profile token ID according to a given handle. - * - * @param handle The handle to resolve the profile token ID with. - * - * @return uint256 The profile ID the passed handle points to. - */ - function getProfileIdByHandle(string calldata handle) external view returns (uint256); - /** * @notice Returns the full profile struct associated with a given profile token ID. * diff --git a/contracts/interfaces/ILensMultiState.sol b/contracts/interfaces/ILensMultiState.sol new file mode 100644 index 0000000..e24d3cc --- /dev/null +++ b/contracts/interfaces/ILensMultiState.sol @@ -0,0 +1,7 @@ +pragma solidity 0.8.15; + +import {DataTypes} from '../libraries/DataTypes.sol'; + +interface ILensMultiState { + function getState() external view returns (DataTypes.ProtocolState); +} diff --git a/contracts/interfaces/ILensNFTBase.sol b/contracts/interfaces/ILensNFTBase.sol index 9ccdd1c..54da496 100644 --- a/contracts/interfaces/ILensNFTBase.sol +++ b/contracts/interfaces/ILensNFTBase.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from '../libraries/DataTypes.sol'; diff --git a/contracts/interfaces/IModuleGlobals.sol b/contracts/interfaces/IModuleGlobals.sol index 4694632..cce75d8 100644 --- a/contracts/interfaces/IModuleGlobals.sol +++ b/contracts/interfaces/IModuleGlobals.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title IModuleGlobals diff --git a/contracts/interfaces/IReferenceModule.sol b/contracts/interfaces/IReferenceModule.sol index a24cf70..e7d8dff 100644 --- a/contracts/interfaces/IReferenceModule.sol +++ b/contracts/interfaces/IReferenceModule.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title IReferenceModule @@ -9,9 +9,19 @@ pragma solidity 0.8.10; * @notice This is the standard interface for all Lens-compatible ReferenceModules. */ interface IReferenceModule { + // function getModuleVersion() external view returns (uint256); + + // function processModuleChange( + // uint256 profileId, + // uint256 pubId, + // bytes calldata data + // ) external; + /** * @notice Initializes data for a given publication being published. This can only be called by the hub. + * * @param profileId The token ID of the profile publishing the publication. + * @param executor The owner or an approved delegated executor. * @param pubId The associated publication's LensHub publication ID. * @param data Arbitrary data passed from the user to be decoded. * @@ -20,6 +30,7 @@ interface IReferenceModule { */ function initializeReferenceModule( uint256 profileId, + address executor, uint256 pubId, bytes calldata data ) external returns (bytes memory); @@ -28,12 +39,14 @@ interface IReferenceModule { * @notice Processes a comment action referencing a given publication. This can only be called by the hub. * * @param profileId The token ID of the profile associated with the publication being published. + * @param executor The commenter or an approved delegated executor. * @param profileIdPointed The profile ID of the profile associated the publication being referenced. * @param pubIdPointed The publication ID of the publication being referenced. * @param data Arbitrary data __passed from the commenter!__ to be decoded. */ function processComment( uint256 profileId, + address executor, uint256 profileIdPointed, uint256 pubIdPointed, bytes calldata data @@ -43,12 +56,14 @@ interface IReferenceModule { * @notice Processes a mirror action referencing a given publication. This can only be called by the hub. * * @param profileId The token ID of the profile associated with the publication being published. + * @param executor The mirror creator or an approved delegated executor. * @param profileIdPointed The profile ID of the profile associated the publication being referenced. * @param pubIdPointed The publication ID of the publication being referenced. * @param data Arbitrary data __passed from the mirrorer!__ to be decoded. */ function processMirror( uint256 profileId, + address executor, uint256 profileIdPointed, uint256 pubIdPointed, bytes calldata data diff --git a/contracts/libraries/Constants.sol b/contracts/libraries/Constants.sol index 7fb7906..b9767a3 100644 --- a/contracts/libraries/Constants.sol +++ b/contracts/libraries/Constants.sol @@ -1,12 +1,125 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -library Constants { - string internal constant FOLLOW_NFT_NAME_SUFFIX = '-Follower'; - string internal constant FOLLOW_NFT_SYMBOL_SUFFIX = '-Fl'; - string internal constant COLLECT_NFT_NAME_INFIX = '-Collect-'; - string internal constant COLLECT_NFT_SYMBOL_INFIX = '-Cl-'; - uint8 internal constant MAX_HANDLE_LENGTH = 31; - uint16 internal constant MAX_PROFILE_IMAGE_URI_LENGTH = 6000; -} +string constant FOLLOW_NFT_NAME_SUFFIX = '-Follower'; +string constant FOLLOW_NFT_SYMBOL_SUFFIX = '-Fl'; +string constant COLLECT_NFT_NAME_INFIX = '-Collect-'; +string constant COLLECT_NFT_SYMBOL_INFIX = '-Cl-'; +uint8 constant MAX_HANDLE_LENGTH = 31; +uint16 constant MAX_PROFILE_IMAGE_URI_LENGTH = 6000; + +// We store constants equal to the storage slots here to later access via inline +// assembly without needing to pass storage pointers. The NAME_SLOT_GT_31 slot +// is equivalent to keccak256(NAME_SLOT) and is where the name string is stored +// if the length is greater than 31 bytes. +uint256 constant NAME_SLOT = 0; +uint256 constant TOKEN_DATA_MAPPING_SLOT = 2; +uint256 constant TOKEN_APPROVAL_MAPPING_SLOT = 4; +uint256 constant OPERATOR_APPROVAL_MAPPING_SLOT = 5; +uint256 constant SIG_NONCES_MAPPING_SLOT = 10; +uint256 constant PROTOCOL_STATE_SLOT = 12; +uint256 constant PROFILE_CREATOR_WHITELIST_MAPPING_SLOT = 13; +uint256 constant FOLLOW_MODULE_WHITELIST_MAPPING_SLOT = 14; +uint256 constant COLLECT_MODULE_WHITELIST_MAPPING_SLOT = 15; +uint256 constant REFERENCE_MODULE_WHITELIST_MAPPING_SLOT = 16; +uint256 constant DISPATCHER_BY_PROFILE_MAPPING_SLOT = 17; +uint256 constant PROFILE_ID_BY_HANDLE_HASH_MAPPING_SLOT = 18; +uint256 constant PROFILE_BY_ID_MAPPING_SLOT = 19; +uint256 constant PUB_BY_ID_BY_PROFILE_MAPPING_SLOT = 20; +uint256 constant DEFAULT_PROFILE_MAPPING_SLOT = 21; +uint256 constant PROFILE_COUNTER_SLOT = 22; +uint256 constant GOVERNANCE_SLOT = 23; +uint256 constant EMERGENCY_ADMIN_SLOT = 24; +uint256 constant DELEGATED_EXECUTOR_APPROVAL_MAPPING_SLOT = 25; +uint256 constant PROFILE_METADATA_MAPPING_SLOT = 26; +uint256 constant BLOCK_STATUS_MAPPING_SLOT = 27; +uint256 constant NAME_SLOT_GT_31 = 0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563; + +// We store the polygon chain ID and domain separator as constants to save gas. +uint256 constant POLYGON_CHAIN_ID = 137; +bytes32 constant POLYGON_DOMAIN_SEPARATOR = 0x78e10b2874b1a1d4436464e65903d3bdc28b68f8d023df2e47b65f8caa45c4bb; +// keccak256( +// abi.encode( +// EIP712_DOMAIN_TYPEHASH, +// keccak256('Lens Protocol Profiles'), +// EIP712_REVISION_HASH, +// POLYGON_CHAIN_ID, +// address(0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d) +// ) +// ); + +// Profile struct offsets +// uint256 pubCount; // offset 0 +uint256 constant PROFILE_FOLLOW_MODULE_OFFSET = 1; +uint256 constant PROFILE_FOLLOW_NFT_OFFSET = 2; +uint256 constant PROFILE_HANDLE_OFFSET = 3; +uint256 constant PROFILE_IMAGE_URI_OFFSET = 4; +uint256 constant PROFILE_FOLLOW_NFT_URI_OFFSET = 5; + +// Publication struct offsets +// uint256 profileIdPointed; // offset 0 +uint256 constant PUBLICATION_PUB_ID_POINTED_OFFSET = 1; +uint256 constant PUBLICATION_CONTENT_URI_OFFSET = 2; // offset 2 +uint256 constant PUBLICATION_REFERENCE_MODULE_OFFSET = 3; // offset 3 +uint256 constant PUBLICATION_COLLECT_MODULE_OFFSET = 4; // offset 4 +uint256 constant PUBLICATION_COLLECT_NFT_OFFSET = 5; // offset 4 + +// We also store typehashes here +bytes32 constant EIP712_REVISION_HASH = keccak256('1'); +bytes32 constant PERMIT_TYPEHASH = keccak256( + 'Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)' +); +bytes32 constant PERMIT_FOR_ALL_TYPEHASH = keccak256( + 'PermitForAll(address owner,address operator,bool approved,uint256 nonce,uint256 deadline)' +); +bytes32 constant BURN_WITH_SIG_TYPEHASH = keccak256( + 'BurnWithSig(uint256 tokenId,uint256 nonce,uint256 deadline)' +); +bytes32 constant EIP712_DOMAIN_TYPEHASH = keccak256( + 'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)' +); +bytes32 constant SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH = keccak256( + 'SetDefaultProfileWithSig(address wallet,uint256 profileId,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH = keccak256( + 'SetFollowModuleWithSig(uint256 profileId,address followModule,bytes followModuleInitData,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_FOLLOW_NFT_URI_WITH_SIG_TYPEHASH = keccak256( + 'SetFollowNFTURIWithSig(uint256 profileId,string followNFTURI,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_DISPATCHER_WITH_SIG_TYPEHASH = keccak256( + 'SetDispatcherWithSig(uint256 profileId,address dispatcher,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_DELEGATED_EXECUTOR_APPROVAL_WITH_SIG_TYPEHASH = keccak256( + 'SetDelegatedExecutorApprovalWithSig(address executor,bool approved,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH = keccak256( + 'SetProfileImageURIWithSig(uint256 profileId,string imageURI,uint256 nonce,uint256 deadline)' +); +bytes32 constant POST_WITH_SIG_TYPEHASH = keccak256( + 'PostWithSig(uint256 profileId,string contentURI,address collectModule,bytes collectModuleInitData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' +); +bytes32 constant COMMENT_WITH_SIG_TYPEHASH = keccak256( + 'CommentWithSig(uint256 profileId,string contentURI,uint256 profileIdPointed,uint256 pubIdPointed,bytes referenceModuleData,address collectModule,bytes collectModuleInitData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' +); +bytes32 constant MIRROR_WITH_SIG_TYPEHASH = keccak256( + 'MirrorWithSig(uint256 profileId,uint256 profileIdPointed,uint256 pubIdPointed,bytes referenceModuleData,address referenceModule,bytes referenceModuleInitData,uint256 nonce,uint256 deadline)' +); +bytes32 constant FOLLOW_WITH_SIG_TYPEHASH = keccak256( + 'FollowWithSig(uint256 followerProfileId,uint256[] idsOfProfilesToFollow,uint256[] followTokenIds,bytes[] datas,uint256 nonce,uint256 deadline)' +); +bytes32 constant UNFOLLOW_WITH_SIG_TYPEHASH = keccak256( + 'UnfollowWithSig(uint256 unfollowerProfileId,uint256[] idsOfProfilesToUnfollow,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_BLOCK_STATUS_WITH_SIG_TYPEHASH = keccak256( + 'SetBlockStatusWithSig(uint256 byProfileId,uint256[] idsOfProfilesToSetBlockStatus,bool[] blockStatus,uint256 nonce,uint256 deadline)' +); +bytes32 constant COLLECT_WITH_SIG_TYPEHASH = keccak256( + 'CollectWithSig(uint256 collectorProfileId,uint256 publisherProfileId,uint256 pubId,bytes data,uint256 nonce,uint256 deadline)' +); +bytes32 constant SET_PROFILE_METADATA_URI_WITH_SIG_TYPEHASH = keccak256( + 'SetProfileMetadataURIWithSig(uint256 profileId,string metadata,uint256 nonce,uint256 deadline)' +); + +bytes4 constant EIP1271_MAGIC_VALUE = 0x1626ba7e; diff --git a/contracts/libraries/DataTypes.sol b/contracts/libraries/DataTypes.sol index 702f142..252c031 100644 --- a/contracts/libraries/DataTypes.sol +++ b/contracts/libraries/DataTypes.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; /** * @title DataTypes @@ -58,17 +58,17 @@ library DataTypes { * @param pubCount The number of publications made to this profile. * @param followModule The address of the current follow module in use by this profile, can be empty. * @param followNFT The address of the followNFT associated with this profile, can be empty.. - * @param handle The profile's associated handle. + * @param handleDeprecated The deprecated handle slot, no longer used. . * @param imageURI The URI to be used for the profile's image. * @param followNFTURI The URI to be used for the follow NFT. */ struct ProfileStruct { - uint256 pubCount; - address followModule; - address followNFT; - string handle; - string imageURI; - string followNFTURI; + uint256 pubCount; // offset 0 + address followModule; // offset 1 + address followNFT; // offset 2 + string handleDeprecated; // offset 3 + string imageURI; // offset 4 + string followNFTURI; // offset 5 } /** @@ -94,7 +94,6 @@ library DataTypes { * @notice A struct containing the parameters required for the `createProfile()` function. * * @param to The address receiving the profile. - * @param handle The handle to set for the profile, must be unique and non-empty. * @param imageURI The URI to set for the profile image. * @param followModule The follow module to use, can be the zero address. * @param followModuleInitData The follow module initialization data, if any. @@ -102,7 +101,6 @@ library DataTypes { */ struct CreateProfileData { address to; - string handle; string imageURI; address followModule; bytes followModuleInitData; @@ -113,11 +111,13 @@ library DataTypes { * @notice A struct containing the parameters required for the `setDefaultProfileWithSig()` function. Parameters are * the same as the regular `setDefaultProfile()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the wallet owner, or a delegated executor. * @param wallet The address of the wallet setting the default profile. * @param profileId The token ID of the profile which will be set as default, or zero. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetDefaultProfileWithSigData { + address delegatedSigner; address wallet; uint256 profileId; EIP712Signature sig; @@ -127,12 +127,14 @@ library DataTypes { * @notice A struct containing the parameters required for the `setFollowModuleWithSig()` function. Parameters are * the same as the regular `setFollowModule()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile to change the followModule for. * @param followModule The followModule to set for the given profile, must be whitelisted. * @param followModuleInitData The data to be passed to the followModule for initialization. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetFollowModuleWithSigData { + address delegatedSigner; uint256 profileId; address followModule; bytes followModuleInitData; @@ -141,7 +143,7 @@ library DataTypes { /** * @notice A struct containing the parameters required for the `setDispatcherWithSig()` function. Parameters are the same - * as the regular `setDispatcher()` function, with an added EIP712Signature. + * as the regular `setDispatcher()` function, with an added EIP712Signature. The signer must be the owner. * * @param profileId The token ID of the profile to set the dispatcher for. * @param dispatcher The dispatcher address to set for the profile. @@ -153,15 +155,33 @@ library DataTypes { EIP712Signature sig; } + /** + * @notice A struct containing the parameters required for the `setDelegatedExecutorApprovalWithSig()` function. Parameters + * are the same as the regular `setDelegatedExecutorApproval()` function. The signer must be the onBehalfOf address. + * + * @param onBehalfOf The address the delegated executor is to be granted or revoked approval to act on behalf of. + * @param executor The executor to set the approval for. + * @param approved Whether the executor is to be approved. + * @param sig The EIP712Signature struct containing to the signer setting the approval's signature. + */ + struct SetDelegatedExecutorApprovalWithSigData { + address onBehalfOf; + address executor; + bool approved; + EIP712Signature sig; + } + /** * @notice A struct containing the parameters required for the `setProfileImageURIWithSig()` function. Parameters are the same * as the regular `setProfileImageURI()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile to set the URI for. * @param imageURI The URI to set for the given profile image. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetProfileImageURIWithSigData { + address delegatedSigner; uint256 profileId; string imageURI; EIP712Signature sig; @@ -171,11 +191,13 @@ library DataTypes { * @notice A struct containing the parameters required for the `setFollowNFTURIWithSig()` function. Parameters are the same * as the regular `setFollowNFTURI()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile for which to set the followNFT URI. * @param followNFTURI The follow NFT URI to set. * @param sig The EIP712Signature struct containing the followNFT's associated profile owner's signature. */ struct SetFollowNFTURIWithSigData { + address delegatedSigner; uint256 profileId; string followNFTURI; EIP712Signature sig; @@ -204,6 +226,7 @@ library DataTypes { * @notice A struct containing the parameters required for the `postWithSig()` function. Parameters are the same as * the regular `post()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param collectModule The collectModule to set for this new publication. @@ -213,6 +236,7 @@ library DataTypes { * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct PostWithSigData { + address delegatedSigner; uint256 profileId; string contentURI; address collectModule; @@ -251,6 +275,7 @@ library DataTypes { * @notice A struct containing the parameters required for the `commentWithSig()` function. Parameters are the same as * the regular `comment()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param profileIdPointed The profile token ID to point the comment to. @@ -263,6 +288,7 @@ library DataTypes { * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct CommentWithSigData { + address delegatedSigner; uint256 profileId; string contentURI; uint256 profileIdPointed; @@ -298,6 +324,7 @@ library DataTypes { * @notice A struct containing the parameters required for the `mirrorWithSig()` function. Parameters are the same as * the regular `mirror()` function, with an added EIP712Signature. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The token ID of the profile to publish to. * @param profileIdPointed The profile token ID to point the mirror to. * @param pubIdPointed The publication ID to point the mirror to. @@ -307,6 +334,7 @@ library DataTypes { * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct MirrorWithSigData { + address delegatedSigner; uint256 profileId; uint256 profileIdPointed; uint256 pubIdPointed; @@ -317,34 +345,93 @@ library DataTypes { } /** - * @notice A struct containing the parameters required for the `followWithSig()` function. Parameters are the same - * as the regular `follow()` function, with the follower's (signer) address and an EIP712Signature added. + * @notice A struct containing the parameters required for the `followWithSig` function. Parameters are the same + * as the regular `follow` function, with the signer address and an EIP712Signature added. * - * @param follower The follower which is the message signer. - * @param profileIds The array of token IDs of the profiles to follow. - * @param datas The array of arbitrary data to pass to the followModules if needed. + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the follower, + * or a delegated executor. + * @param followerProfileId The ID of the profile the follows are being executed for. + * @param idsOfProfilesToFollow The array of IDs of profiles to follow. + * @param followTokenIds The array of follow token IDs to use for each follow. + * @param datas The arbitrary data array to pass to the follow module for each profile if needed. * @param sig The EIP712Signature struct containing the follower's signature. */ struct FollowWithSigData { - address follower; - uint256[] profileIds; + address delegatedSigner; + uint256 followerProfileId; + uint256[] idsOfProfilesToFollow; + uint256[] followTokenIds; bytes[] datas; EIP712Signature sig; } + /** + * @notice A struct containing the parameters required for the `unfollowWithSig` function. Parameters are the same + * as the regular `unfollow` function, with the signer address and an EIP712Signature added. + * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the follower, + * or a delegated executor. + * @param unfollowerProfileId The ID of the profile the unfollows are being executed for. + * @param idsOfProfilesToUnfollow The array of IDs of profiles to unfollow. + * @param sig The EIP712Signature struct containing the follower's signature. + */ + struct UnfollowWithSigData { + address delegatedSigner; + uint256 unfollowerProfileId; + uint256[] idsOfProfilesToUnfollow; + EIP712Signature sig; + } + + /** + * @notice A struct containing the parameters required for the `setBlockStatusWithSig` function. Parameters are the + * same as the regular `setBlockStatus` function, with the signer address and an EIP712Signature added. + * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the blocker, + * or a delegated executor. + * @param byProfileId The ID of the profile the block status sets are being executed for. + * @param idsOfProfilesToSetBlockStatus The array of IDs of profiles to set block status. + * @param blockStatus The array of block status to use for each setting. + * @param sig The EIP712Signature struct containing the blocker's signature. + */ + struct SetBlockStatusWithSigData { + address delegatedSigner; + uint256 byProfileId; + uint256[] idsOfProfilesToSetBlockStatus; + bool[] blockStatus; + EIP712Signature sig; + } + + /** + * @notice A struct containing the parameters required for the `collect()` function. + * + * @param collector The address of the collector. + * @param profileId The token ID of the profile to that published the content being collected. + * @param pubId The ID of the publication being collected. + * @param data The data passed to the collect module. + */ + struct CollectData { + // TODO: Move this to tests? And the one below + uint256 collectorProfileId; + uint256 publisherProfileId; + uint256 pubId; + bytes data; + } + /** * @notice A struct containing the parameters required for the `collectWithSig()` function. Parameters are the same as * the regular `collect()` function, with the collector's (signer) address and an EIP712Signature added. * - * @param collector The collector which is the message signer. - * @param profileId The token ID of the profile that published the publication to collect. + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the collector profile owner, or a delegated executor. + * @param collectorProfileId The collector profile. + * @param publisherProfileId The token ID of the profile that published the publication to collect. * @param pubId The publication to collect's publication ID. * @param data The arbitrary data to pass to the collectModule if needed. * @param sig The EIP712Signature struct containing the collector's signature. */ struct CollectWithSigData { - address collector; - uint256 profileId; + address delegatedSigner; + uint256 collectorProfileId; + uint256 publisherProfileId; uint256 pubId; bytes data; EIP712Signature sig; @@ -353,19 +440,23 @@ library DataTypes { /** * @notice A struct containing the parameters required for the `setProfileMetadataWithSig()` function. * + * @param delegatedSigner The delegated executor signer, must be either zero, defaulting to the profile owner, or a delegated executor. * @param profileId The profile ID for which to set the metadata. - * @param metadata The metadata string to set for the profile and user. + * @param metadataURI The metadata string to set for the profile and user. * @param sig The EIP712Signature struct containing the user's signature. */ - struct SetProfileMetadataWithSigData { + struct SetProfileMetadataURIWithSigData { + address delegatedSigner; uint256 profileId; - string metadata; + string metadataURI; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `toggleFollowWithSig()` function. * + * @note This does not include a delegatedSigner parameter as it is marked for deprecation. + * * @param follower The follower which is the message signer. * @param profileIds The token ID array of the profiles. * @param enables The array of booleans to enable/disable follows. diff --git a/contracts/libraries/Errors.sol b/contracts/libraries/Errors.sol index 41a5809..bed60be 100644 --- a/contracts/libraries/Errors.sol +++ b/contracts/libraries/Errors.sol @@ -1,8 +1,31 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; library Errors { + // ERC721Time Errors + error ERC721Time_BalanceQueryForZeroAddress(); + error ERC721Time_OwnerQueryForNonexistantToken(); + error ERC721Time_MintTimestampQueryForNonexistantToken(); + error ERC721Time_TokenDataQueryForNonexistantToken(); + error ERC721Time_URIQueryForNonexistantToken(); + error ERC721Time_ApprovalToCurrentOwner(); + error ERC721Time_ApproveCallerNotOwnerOrApprovedForAll(); + error ERC721Time_ApprovedQueryForNonexistantToken(); + error ERC721Time_ApproveToCaller(); + error ERC721Time_TransferCallerNotOwnerOrApproved(); + error ERC721Time_TransferToNonERC721ReceiverImplementer(); + error ERC721Time_OperatorQueryForNonexistantToken(); + error ERC721Time_MintToZeroAddress(); + error ERC721Time_TokenAlreadyMinted(); + error ERC721Time_TransferOfTokenThatIsNotOwn(); + error ERC721Time_TransferToZeroAddress(); + + // ERC721Enumerable Errors + error ERC721Enumerable_OwnerIndexOutOfBounds(); + error ERC721Enumerable_GlobalIndexOutOfBounds(); + + // Lens Protocol Errors error CannotInitImplementation(); error Initialized(); error SignatureExpired(); @@ -13,14 +36,14 @@ library Errors { error TokenDoesNotExist(); error NotGovernance(); error NotGovernanceOrEmergencyAdmin(); - error EmergencyAdminCannotUnpause(); + error EmergencyAdminCanOnlyPauseFurther(); error CallerNotWhitelistedModule(); error CollectModuleNotWhitelisted(); error FollowModuleNotWhitelisted(); error ReferenceModuleNotWhitelisted(); error ProfileCreatorNotWhitelisted(); error NotProfileOwner(); - error NotProfileOwnerOrDispatcher(); + error NotProfileOwnerOrValid(); // deprecated error NotDispatcher(); error PublicationDoesNotExist(); error HandleTaken(); @@ -35,6 +58,11 @@ library Errors { error CannotCommentOnSelf(); error NotWhitelisted(); error InvalidParameter(); + error ExecutorInvalid(); + error Blocked(); + error SelfBlock(); + error NotFollowing(); + error SelfFollow(); // Module Errors error InitParamsInvalid(); diff --git a/contracts/libraries/Events.sol b/contracts/libraries/Events.sol index bdd8e59..e868393 100644 --- a/contracts/libraries/Events.sol +++ b/contracts/libraries/Events.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from './DataTypes.sol'; @@ -119,7 +119,6 @@ library Events { * @param profileId The newly created profile's token ID. * @param creator The profile creator, who created the token with the given profile ID. * @param to The address receiving the profile with the given profile ID. - * @param handle The handle set for the profile. * @param imageURI The image uri set for the profile. * @param followModule The profile's newly set follow module. This CAN be the zero address. * @param followModuleReturnData The data returned from the follow module's initialization. This is abi encoded @@ -131,7 +130,6 @@ library Events { uint256 indexed profileId, address indexed creator, address indexed to, - string handle, string imageURI, address followModule, bytes followModuleReturnData, @@ -157,6 +155,19 @@ library Events { */ event DispatcherSet(uint256 indexed profileId, address indexed dispatcher, uint256 timestamp); + /** + * @dev Emitted when a delegated executor is granted or revoked approval to act on behalf of a given address. + * + * @param onBehalfOf The address the delegated executor is granted or revoked approval to act on behalf of. + * @param executor The address of the delegated executor granted or revoked approval. + * @param approved Whether the executor is approved. + */ + event DelegatedExecutorApprovalSet( + address indexed onBehalfOf, + address indexed executor, + bool indexed approved + ); + /** * @dev Emitted when a profile's URI is set. * @@ -302,8 +313,8 @@ library Events { /** * @dev Emitted upon a successful collect action. * - * @param collector The address collecting the publication. - * @param profileId The token ID of the profile that the collect was initiated towards, useful to differentiate mirrors. + * @param collectorProfileId The address collecting the publication. + * @param publisherProfileId The token ID of the profile that the collect was initiated towards, useful to differentiate mirrors. * @param pubId The publication ID that the collect was initiated towards, useful to differentiate mirrors. * @param rootProfileId The profile token ID of the profile whose publication is being collected. * @param rootPubId The publication ID of the publication being collected. @@ -311,8 +322,8 @@ library Events { * @param timestamp The current block timestamp. */ event Collected( - address indexed collector, - uint256 indexed profileId, + uint256 indexed collectorProfileId, + uint256 indexed publisherProfileId, uint256 indexed pubId, uint256 rootProfileId, uint256 rootPubId, @@ -321,20 +332,53 @@ library Events { ); /** - * @dev Emitted upon a successful follow action. + * @dev Emitted upon a successful follow operation. * - * @param follower The address following the given profiles. - * @param profileIds The token ID array of the profiles being followed. - * @param followModuleDatas The array of data parameters passed to each follow module. - * @param timestamp The current block timestamp. + * @param followerProfileId The ID of the profile that executed the follow. + * @param idOfProfileFollowed The ID of the profile that was followed. + * @param followTokenIdAssigned The ID of the follow token assigned to the follower. + * @param followModuleData The data to passed to the follow module, if any. + * @param timestamp The timestamp of the follow operation. */ event Followed( - address indexed follower, - uint256[] profileIds, - bytes[] followModuleDatas, + uint256 indexed followerProfileId, + uint256 idOfProfileFollowed, + uint256 followTokenIdAssigned, + bytes followModuleData, uint256 timestamp ); + /** + * @dev Emitted upon a successful unfollow operation. + * + * @param unfollowerProfileId The ID of the profile that executed the unfollow. + * @param idOfProfileUnfollowed The ID of the profile that was unfollowed. + * @param timestamp The timestamp of the unfollow operation. + */ + event Unfollowed( + uint256 indexed unfollowerProfileId, + uint256 idOfProfileUnfollowed, + uint256 timestamp + ); + + /** + * @dev Emitted upon a successful block, through a block status setting operation. + * + * @param byProfileId The ID of the profile that executed the block status change. + * @param idOfProfileBlocked The ID of the profile whose block status have been set to blocked. + * @param timestamp The timestamp of the block operation. + */ + event Blocked(uint256 indexed byProfileId, uint256 idOfProfileBlocked, uint256 timestamp); + + /** + * @dev Emitted upon a successful unblock, through a block status setting operation. + * + * @param byProfileId The ID of the profile that executed the block status change. + * @param idOfProfileUnblocked The ID of the profile whose block status have been set to unblocked. + * @param timestamp The timestamp of the unblock operation. + */ + event Unblocked(uint256 indexed byProfileId, uint256 idOfProfileUnblocked, uint256 timestamp); + /** * @dev Emitted via callback when a followNFT is transferred. * diff --git a/contracts/libraries/GeneralLib.sol b/contracts/libraries/GeneralLib.sol new file mode 100644 index 0000000..50a63aa --- /dev/null +++ b/contracts/libraries/GeneralLib.sol @@ -0,0 +1,485 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {GeneralHelpers} from './helpers/GeneralHelpers.sol'; +import {MetaTxHelpers} from './helpers/MetaTxHelpers.sol'; +import {InteractionHelpers} from './helpers/InteractionHelpers.sol'; +import {DataTypes} from './DataTypes.sol'; +import {Errors} from './Errors.sol'; +import {Events} from './Events.sol'; +import {IFollowModule} from '../interfaces/IFollowModule.sol'; +import {ICollectModule} from '../interfaces/ICollectModule.sol'; +import {IReferenceModule} from '../interfaces/IReferenceModule.sol'; +import {IDeprecatedFollowModule} from '../interfaces/IDeprecatedFollowModule.sol'; +import {IDeprecatedCollectModule} from '../interfaces/IDeprecatedCollectModule.sol'; +import {IDeprecatedReferenceModule} from '../interfaces/IDeprecatedReferenceModule.sol'; + +import './Constants.sol'; + +/** + * @title GeneralLib + * @author Lens Protocol + * + * @notice This is the library that contains logic to be called by the hub via `delegateCall`. + * + * Note: The setDispatcher non-signature function was not migrated as it was more space-efficient + * to leave it in the hub. + */ +library GeneralLib { + /** + * @notice Sets the governance address. + * + * @param newGovernance The new governance address to set. + */ + function setGovernance(address newGovernance) external { + address prevGovernance; + assembly { + prevGovernance := sload(GOVERNANCE_SLOT) + sstore(GOVERNANCE_SLOT, newGovernance) + } + emit Events.GovernanceSet(msg.sender, prevGovernance, newGovernance, block.timestamp); + } + + /** + * @notice Sets the emergency admin address. + * + * @param newEmergencyAdmin The new governance address to set. + */ + function setEmergencyAdmin(address newEmergencyAdmin) external { + address prevEmergencyAdmin; + assembly { + prevEmergencyAdmin := sload(EMERGENCY_ADMIN_SLOT) + sstore(EMERGENCY_ADMIN_SLOT, newEmergencyAdmin) + } + emit Events.EmergencyAdminSet( + msg.sender, + prevEmergencyAdmin, + newEmergencyAdmin, + block.timestamp + ); + } + + /** + * @notice Sets the protocol state, only meant to be called at initialization since + * this does nto validate the caller. + * + * @param newState The new protocol state to set. + */ + function initState(DataTypes.ProtocolState newState) external { + DataTypes.ProtocolState prevState; + assembly { + prevState := sload(PROTOCOL_STATE_SLOT) + sstore(PROTOCOL_STATE_SLOT, newState) + } + emit Events.StateSet(msg.sender, prevState, newState, block.timestamp); + } + + /** + * @notice Sets the protocol state and validates the caller. The emergency admin can only + * pause further (Unpaused => PublishingPaused => Paused). Whereas governance can set any + * state. + * + * @param newState The new protocol state to set. + */ + function setState(DataTypes.ProtocolState newState) external { + address emergencyAdmin; + address governance; + DataTypes.ProtocolState prevState; + + // Load the emergency admin, governance and protocol state, then store the new protocol + // state via assembly. + assembly { + emergencyAdmin := sload(EMERGENCY_ADMIN_SLOT) + governance := sload(GOVERNANCE_SLOT) + prevState := sload(PROTOCOL_STATE_SLOT) + sstore(PROTOCOL_STATE_SLOT, newState) + } + + // If the sender is the emergency admin, prevent them from reducing restrictions. + if (msg.sender == emergencyAdmin) { + if (newState <= prevState) revert Errors.EmergencyAdminCanOnlyPauseFurther(); + } else if (msg.sender != governance) { + revert Errors.NotGovernanceOrEmergencyAdmin(); + } + emit Events.StateSet(msg.sender, prevState, newState, block.timestamp); + } + + /** + * @notice Sets the default profile for a given wallet. + * + * @param onBehalfOf The wallet to set the default profile for. + * @param profileId The profile ID to set. + */ + function setDefaultProfile(address onBehalfOf, uint256 profileId) external { + _validateCallerIsOnBehalfOfOrExecutor(onBehalfOf); + _setDefaultProfile(onBehalfOf, profileId); + } + + /** + * @notice Sets the default profile via signature for a given owner. + * + * @param vars the SetDefaultProfileWithSigData struct containing the relevant parameters. + */ + function setDefaultProfileWithSig(DataTypes.SetDefaultProfileWithSigData calldata vars) + external + { + uint256 profileId = vars.profileId; + address wallet = vars.wallet; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + wallet, + vars.delegatedSigner + ); + MetaTxHelpers.baseSetDefaultProfileWithSig(signer, vars); + _setDefaultProfile(wallet, profileId); + } + + function setDelegatedExecutorApproval(address executor, bool approved) external { + _setDelegatedExecutorApproval(msg.sender, executor, approved); + } + + function setDelegatedExecutorApprovalWithSig( + DataTypes.SetDelegatedExecutorApprovalWithSigData calldata vars + ) external { + MetaTxHelpers.baseSetDelegatedExecutorApprovalWithSig(vars); + _setDelegatedExecutorApproval(vars.onBehalfOf, vars.executor, vars.approved); + } + + /** + * @notice Follows the given profiles, executing the necessary logic and module calls before minting the follow + * NFT(s) to the follower. + * + * @param followerProfileId The profile the follow is being executed for. + * @param idsOfProfilesToFollow The array of profile token IDs to follow. + * @param followTokenIds The array of follow token IDs to use for each follow. + * @param followModuleDatas The array of follow module data parameters to pass to each profile's follow module. + * + * @return uint256[] An array of integers representing the minted follow NFTs token IDs. + */ + function follow( + uint256 followerProfileId, + uint256[] calldata idsOfProfilesToFollow, + uint256[] calldata followTokenIds, + bytes[] calldata followModuleDatas + ) external returns (uint256[] memory) { + GeneralHelpers.validateCallerIsOwnerOrDelegatedExecutor(followerProfileId); + return + InteractionHelpers.follow({ + followerProfileId: followerProfileId, + executor: msg.sender, + idsOfProfilesToFollow: idsOfProfilesToFollow, + followTokenIds: followTokenIds, + followModuleDatas: followModuleDatas + }); + } + + /** + * @notice Validates parameters and increments the nonce for a given owner using the + * `followWithSig()` function. + * + * @param vars the FollowWithSigData struct containing the relevant parameters. + */ + function followWithSig(DataTypes.FollowWithSigData calldata vars) + external + returns (uint256[] memory) + { + address followerProfileOwner = GeneralHelpers.ownerOf(vars.followerProfileId); + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + followerProfileOwner, + vars.delegatedSigner + ); + MetaTxHelpers.baseFollowWithSig(signer, vars); + return + InteractionHelpers.follow({ + followerProfileId: vars.followerProfileId, + executor: signer, + idsOfProfilesToFollow: vars.idsOfProfilesToFollow, + followTokenIds: vars.followTokenIds, + followModuleDatas: vars.datas + }); + } + + function unfollow(uint256 unfollowerProfileId, uint256[] calldata idsOfProfilesToUnfollow) + external + { + GeneralHelpers.validateCallerIsOwnerOrDelegatedExecutor(unfollowerProfileId); + return + InteractionHelpers.unfollow({ + unfollowerProfileId: unfollowerProfileId, + executor: msg.sender, + idsOfProfilesToUnfollow: idsOfProfilesToUnfollow + }); + } + + /** + * @notice Validates parameters and increments the nonce for a given owner using the + * `unfollowWithSig()` function. + * + * @param vars the UnfollowWithSigData struct containing the relevant parameters. + */ + function unfollowWithSig(DataTypes.UnfollowWithSigData calldata vars) external { + address unfollowerProfileOwner = GeneralHelpers.ownerOf(vars.unfollowerProfileId); + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + unfollowerProfileOwner, + vars.delegatedSigner + ); + MetaTxHelpers.baseUnfollowWithSig(signer, vars); + return + InteractionHelpers.unfollow({ + unfollowerProfileId: vars.unfollowerProfileId, + executor: signer, + idsOfProfilesToUnfollow: vars.idsOfProfilesToUnfollow + }); + } + + function setBlockStatus( + uint256 byProfileId, + uint256[] calldata idsOfProfilesToSetBlockStatus, + bool[] calldata blockStatus + ) external { + GeneralHelpers.validateCallerIsOwnerOrDelegatedExecutor(byProfileId); + InteractionHelpers.setBlockStatus(byProfileId, idsOfProfilesToSetBlockStatus, blockStatus); + } + + function setBlockStatusWithSig(DataTypes.SetBlockStatusWithSigData calldata vars) external { + address blockerProfileOwner = GeneralHelpers.ownerOf(vars.byProfileId); + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + blockerProfileOwner, + vars.delegatedSigner + ); + MetaTxHelpers.baseSetBlockStatusWithSig(signer, vars); + InteractionHelpers.setBlockStatus( + vars.byProfileId, + vars.idsOfProfilesToSetBlockStatus, + vars.blockStatus + ); + } + + /** + * @notice Collects the given publication, executing the necessary logic and module call before minting the + * collect NFT to the collector. + * + * @param collectorProfileId The profile that collect is being executed for. + * @param publisherProfileId The token ID of the publisher profile of the collected publication. + * @param pubId The publication ID of the publication being collected. + * @param collectModuleData The data to pass to the publication's collect module. + * @param collectNFTImpl The address of the collect NFT implementation, which has to be passed because it's an immutable in the hub. + * + * @return uint256 An integer representing the minted token ID. + */ + function collect( + uint256 collectorProfileId, + uint256 publisherProfileId, + uint256 pubId, + bytes calldata collectModuleData, + address collectNFTImpl + ) external returns (uint256) { + return + InteractionHelpers.collect({ + collectorProfileId: collectorProfileId, + collectorProfileOwner: GeneralHelpers.ownerOf(collectorProfileId), + transactionExecutor: msg.sender, + publisherProfileId: publisherProfileId, + pubId: pubId, + collectModuleData: collectModuleData, + collectNFTImpl: collectNFTImpl + }); + } + + /** + * @notice Validates parameters and increments the nonce for a given owner using the + * `collectWithSig()` function. + * + * @param vars the CollectWithSigData struct containing the relevant parameters. + */ + function collectWithSig(DataTypes.CollectWithSigData calldata vars, address collectNFTImpl) + external + returns (uint256) + { + address collectorProfileOwner = GeneralHelpers.ownerOf(vars.collectorProfileId); + address transactionSigner = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + collectorProfileOwner, + vars.delegatedSigner + ); + MetaTxHelpers.baseCollectWithSig(transactionSigner, vars); + return + InteractionHelpers.collect({ + collectorProfileId: vars.collectorProfileId, + collectorProfileOwner: collectorProfileOwner, + transactionExecutor: transactionSigner, + publisherProfileId: vars.publisherProfileId, + pubId: vars.pubId, + collectModuleData: vars.data, + collectNFTImpl: collectNFTImpl + }); + } + + /** + * @notice Approves an address to spend a token using via signature. + * + * @param spender The spender to approve. + * @param tokenId The token ID to approve the spender for. + * @param sig the EIP712Signature struct containing the token owner's signature. + */ + function permit( + address spender, + uint256 tokenId, + DataTypes.EIP712Signature calldata sig + ) external { + // The `Approved()` event is emitted from `basePermit()`. + MetaTxHelpers.basePermit(spender, tokenId, sig); + + // Store the approved address in the token's approval mapping slot. + assembly { + mstore(0, tokenId) + mstore(32, TOKEN_APPROVAL_MAPPING_SLOT) + let slot := keccak256(0, 64) + sstore(slot, spender) + } + } + + /** + * @notice Approves a user to operate on all of an owner's tokens via signature. + * + * @param owner The owner to approve the operator for, this is the signer. + * @param operator The operator to approve for the owner. + * @param approved Whether or not the operator should be approved. + * @param sig the EIP712Signature struct containing the token owner's signature. + */ + function permitForAll( + address owner, + address operator, + bool approved, + DataTypes.EIP712Signature calldata sig + ) external { + // The `ApprovedForAll()` event is emitted from `basePermitForAll()`. + MetaTxHelpers.basePermitForAll(owner, operator, approved, sig); + + // Store whether the operator is approved in the appropriate mapping slot. + assembly { + mstore(0, owner) + mstore(32, OPERATOR_APPROVAL_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, operator) + let slot := keccak256(0, 64) + sstore(slot, approved) + } + } + + /** + * @notice Validates parameters and increments the nonce for a given owner using the + * `burnWithSig()` function. + * + * @param tokenId The token ID to burn. + * @param sig the EIP712Signature struct containing the token owner's signature. + */ + function baseBurnWithSig(uint256 tokenId, DataTypes.EIP712Signature calldata sig) external { + MetaTxHelpers.baseBurnWithSig(tokenId, sig); + } + + /** + * @notice Returns the domain separator. + * + * @return bytes32 The domain separator. + */ + function getDomainSeparator() external view returns (bytes32) { + return MetaTxHelpers.getDomainSeparator(); + } + + function getContentURI(uint256 profileId, uint256 pubId) external view returns (string memory) { + (uint256 rootProfileId, uint256 rootPubId) = GeneralHelpers.getPointedIfMirror( + profileId, + pubId + ); + string memory ptr; + assembly { + // Load the free memory pointer, where we'll return the value + ptr := mload(64) + + // Load the slot, which either contains the content URI + 2*length if length < 32 or + // 2*length+1 if length >= 32, and the actual string starts at slot keccak256(slot) + mstore(0, rootProfileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, rootPubId) + + let slot := add(keccak256(0, 64), PUBLICATION_CONTENT_URI_OFFSET) + + let slotLoad := sload(slot) + let size + // Determine if the length > 32 by checking the lowest order bit, meaning the string + // itself is stored at keccak256(slot) + switch and(slotLoad, 1) + case 0 { + // The content URI is in the same slot + // Determine the size by dividing the last byte's value by 2 + size := shr(1, and(slotLoad, 255)) + + // Store the size in the first slot + mstore(ptr, size) + + // Store the actual string in the second slot (without the size) + mstore(add(ptr, 32), and(slotLoad, not(255))) + } + case 1 { + // The content URI is not in the same slot + // Determine the size by dividing the value in the whole slot minus 1 by 2 + size := shr(1, sub(slotLoad, 1)) + + // Store the size in the first slot + mstore(ptr, size) + + // Compute the total memory slots we need, this is (size + 31) / 32 + let totalMemorySlots := shr(5, add(size, 31)) + + mstore(0, slot) + let uriSlot := keccak256(0, 32) + + // Iterate through the words in memory and store the string word by word + // prettier-ignore + for { let i := 0 } lt(i, totalMemorySlots) { i := add(i, 1) } { + mstore(add(add(ptr, 32), mul(32, i)), sload(add(uriSlot, i))) + } + } + // Store the new memory pointer in the free memory pointer slot + mstore(64, add(add(ptr, 32), size)) + } + return ptr; + } + + function _setDefaultProfile(address wallet, uint256 profileId) private { + if (profileId != 0 && wallet != GeneralHelpers.unsafeOwnerOf(profileId)) + revert Errors.NotProfileOwner(); + + // Store the default profile in the appropriate slot for the given wallet. + assembly { + mstore(0, wallet) + mstore(32, DEFAULT_PROFILE_MAPPING_SLOT) + let slot := keccak256(0, 64) + sstore(slot, profileId) + } + emit Events.DefaultProfileSet(wallet, profileId, block.timestamp); + } + + function _setDelegatedExecutorApproval( + address onBehalfOf, + address executor, + bool approved + ) private { + // Store the approval in the appropriate slot for the given caller and executor. + assembly { + mstore(0, onBehalfOf) + mstore(32, DELEGATED_EXECUTOR_APPROVAL_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, executor) + let slot := keccak256(0, 64) + sstore(slot, approved) + } + emit Events.DelegatedExecutorApprovalSet(onBehalfOf, executor, approved); + } + + function _validateCallerIsOnBehalfOfOrExecutor(address onBehalfOf) private view { + if (onBehalfOf != msg.sender) + GeneralHelpers.validateDelegatedExecutor(onBehalfOf, msg.sender); + } +} diff --git a/contracts/libraries/Helpers.sol b/contracts/libraries/Helpers.sol deleted file mode 100644 index 785f3c3..0000000 --- a/contracts/libraries/Helpers.sol +++ /dev/null @@ -1,57 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.10; - -import {DataTypes} from './DataTypes.sol'; -import {Errors} from './Errors.sol'; - -/** - * @title Helpers - * @author Lens Protocol - * - * @notice This is a library that only contains a single function that is used in the hub contract as well as in - * both the publishing logic and interaction logic libraries. - */ -library Helpers { - /** - * @notice This helper function just returns the pointed publication if the passed publication is a mirror, - * otherwise it returns the passed publication. - * - * @param profileId The token ID of the profile that published the given publication. - * @param pubId The publication ID of the given publication. - * @param _pubByIdByProfile A pointer to the storage mapping of publications by pubId by profile ID. - * - * @return tuple First, the pointed publication's publishing profile ID, second, the pointed publication's ID, and third, the - * pointed publication's collect module. If the passed publication is not a mirror, this returns the given publication. - */ - function getPointedIfMirror( - uint256 profileId, - uint256 pubId, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile - ) - internal - view - returns ( - uint256, - uint256, - address - ) - { - address collectModule = _pubByIdByProfile[profileId][pubId].collectModule; - if (collectModule != address(0)) { - return (profileId, pubId, collectModule); - } else { - uint256 pointedTokenId = _pubByIdByProfile[profileId][pubId].profileIdPointed; - // We validate existence here as an optimization, so validating in calling contracts is unnecessary - if (pointedTokenId == 0) revert Errors.PublicationDoesNotExist(); - - uint256 pointedPubId = _pubByIdByProfile[profileId][pubId].pubIdPointed; - - address pointedCollectModule = _pubByIdByProfile[pointedTokenId][pointedPubId] - .collectModule; - - return (pointedTokenId, pointedPubId, pointedCollectModule); - } - } -} diff --git a/contracts/libraries/InteractionLogic.sol b/contracts/libraries/InteractionLogic.sol deleted file mode 100644 index 98b3fc7..0000000 --- a/contracts/libraries/InteractionLogic.sol +++ /dev/null @@ -1,223 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.10; - -import {FollowNFTProxy} from '../upgradeability/FollowNFTProxy.sol'; -import {Helpers} from './Helpers.sol'; -import {DataTypes} from './DataTypes.sol'; -import {Errors} from './Errors.sol'; -import {Events} from './Events.sol'; -import {Constants} from './Constants.sol'; -import {IFollowNFT} from '../interfaces/IFollowNFT.sol'; -import {ICollectNFT} from '../interfaces/ICollectNFT.sol'; -import {IFollowModule} from '../interfaces/IFollowModule.sol'; -import {ICollectModule} from '../interfaces/ICollectModule.sol'; -import {Clones} from '@openzeppelin/contracts/proxy/Clones.sol'; -import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; - -/** - * @title InteractionLogic - * @author Lens Protocol - * - * @notice This is the library that contains the logic for follows & collects. - - * @dev The functions are external, so they are called from the hub via `delegateCall` under the hood. - */ -library InteractionLogic { - using Strings for uint256; - - /** - * @notice Follows the given profiles, executing the necessary logic and module calls before minting the follow - * NFT(s) to the follower. - * - * @param follower The address executing the follow. - * @param profileIds The array of profile token IDs to follow. - * @param followModuleDatas The array of follow module data parameters to pass to each profile's follow module. - * @param _profileById A pointer to the storage mapping of profile structs by profile ID. - * @param _profileIdByHandleHash A pointer to the storage mapping of profile IDs by handle hash. - * - * @return uint256[] An array of integers representing the minted follow NFTs token IDs. - */ - function follow( - address follower, - uint256[] calldata profileIds, - bytes[] calldata followModuleDatas, - mapping(uint256 => DataTypes.ProfileStruct) storage _profileById, - mapping(bytes32 => uint256) storage _profileIdByHandleHash - ) external returns (uint256[] memory) { - if (profileIds.length != followModuleDatas.length) revert Errors.ArrayMismatch(); - uint256[] memory tokenIds = new uint256[](profileIds.length); - for (uint256 i = 0; i < profileIds.length; ) { - string memory handle = _profileById[profileIds[i]].handle; - if (_profileIdByHandleHash[keccak256(bytes(handle))] != profileIds[i]) - revert Errors.TokenDoesNotExist(); - - address followModule = _profileById[profileIds[i]].followModule; - address followNFT = _profileById[profileIds[i]].followNFT; - - if (followNFT == address(0)) { - followNFT = _deployFollowNFT(profileIds[i]); - _profileById[profileIds[i]].followNFT = followNFT; - } - - tokenIds[i] = IFollowNFT(followNFT).mint(follower); - - if (followModule != address(0)) { - IFollowModule(followModule).processFollow( - follower, - profileIds[i], - followModuleDatas[i] - ); - } - unchecked { - ++i; - } - } - emit Events.Followed(follower, profileIds, followModuleDatas, block.timestamp); - return tokenIds; - } - - /** - * @notice Collects the given publication, executing the necessary logic and module call before minting the - * collect NFT to the collector. - * - * @param collector The address executing the collect. - * @param profileId The token ID of the publication being collected's parent profile. - * @param pubId The publication ID of the publication being collected. - * @param collectModuleData The data to pass to the publication's collect module. - * @param collectNFTImpl The address of the collect NFT implementation, which has to be passed because it's an immutable in the hub. - * @param _pubByIdByProfile A pointer to the storage mapping of publications by pubId by profile ID. - * @param _profileById A pointer to the storage mapping of profile structs by profile ID. - * - * @return uint256 An integer representing the minted token ID. - */ - function collect( - address collector, - uint256 profileId, - uint256 pubId, - bytes calldata collectModuleData, - address collectNFTImpl, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(uint256 => DataTypes.ProfileStruct) storage _profileById - ) external returns (uint256) { - (uint256 rootProfileId, uint256 rootPubId, address rootCollectModule) = Helpers - .getPointedIfMirror(profileId, pubId, _pubByIdByProfile); - - uint256 tokenId; - // Avoids stack too deep - { - address collectNFT = _pubByIdByProfile[rootProfileId][rootPubId].collectNFT; - if (collectNFT == address(0)) { - collectNFT = _deployCollectNFT( - rootProfileId, - rootPubId, - _profileById[rootProfileId].handle, - collectNFTImpl - ); - _pubByIdByProfile[rootProfileId][rootPubId].collectNFT = collectNFT; - } - tokenId = ICollectNFT(collectNFT).mint(collector); - } - - ICollectModule(rootCollectModule).processCollect( - profileId, - collector, - rootProfileId, - rootPubId, - collectModuleData - ); - _emitCollectedEvent( - collector, - profileId, - pubId, - rootProfileId, - rootPubId, - collectModuleData - ); - - return tokenId; - } - - /** - * @notice Deploys the given profile's Follow NFT contract. - * - * @param profileId The token ID of the profile which Follow NFT should be deployed. - * - * @return address The address of the deployed Follow NFT contract. - */ - function _deployFollowNFT(uint256 profileId) private returns (address) { - bytes memory functionData = abi.encodeWithSelector( - IFollowNFT.initialize.selector, - profileId - ); - address followNFT = address(new FollowNFTProxy(functionData)); - emit Events.FollowNFTDeployed(profileId, followNFT, block.timestamp); - - return followNFT; - } - - /** - * @notice Deploys the given profile's Collect NFT contract. - * - * @param profileId The token ID of the profile which Collect NFT should be deployed. - * @param pubId The publication ID of the publication being collected, which Collect NFT should be deployed. - * @param handle The profile's associated handle. - * @param collectNFTImpl The address of the Collect NFT implementation that should be used for the deployment. - * - * @return address The address of the deployed Collect NFT contract. - */ - function _deployCollectNFT( - uint256 profileId, - uint256 pubId, - string memory handle, - address collectNFTImpl - ) private returns (address) { - address collectNFT = Clones.clone(collectNFTImpl); - - bytes4 firstBytes = bytes4(bytes(handle)); - - string memory collectNFTName = string( - abi.encodePacked(handle, Constants.COLLECT_NFT_NAME_INFIX, pubId.toString()) - ); - string memory collectNFTSymbol = string( - abi.encodePacked(firstBytes, Constants.COLLECT_NFT_SYMBOL_INFIX, pubId.toString()) - ); - - ICollectNFT(collectNFT).initialize(profileId, pubId, collectNFTName, collectNFTSymbol); - emit Events.CollectNFTDeployed(profileId, pubId, collectNFT, block.timestamp); - - return collectNFT; - } - - /** - * @notice Emits the `Collected` event that signals that a successful collect action has occurred. - * - * @dev This is done through this function to prevent stack too deep compilation error. - * - * @param collector The address collecting the publication. - * @param profileId The token ID of the profile that the collect was initiated towards, useful to differentiate mirrors. - * @param pubId The publication ID that the collect was initiated towards, useful to differentiate mirrors. - * @param rootProfileId The profile token ID of the profile whose publication is being collected. - * @param rootPubId The publication ID of the publication being collected. - * @param data The data passed to the collect module. - */ - function _emitCollectedEvent( - address collector, - uint256 profileId, - uint256 pubId, - uint256 rootProfileId, - uint256 rootPubId, - bytes calldata data - ) private { - emit Events.Collected( - collector, - profileId, - pubId, - rootProfileId, - rootPubId, - data, - block.timestamp - ); - } -} diff --git a/contracts/libraries/ProfileLib.sol b/contracts/libraries/ProfileLib.sol new file mode 100644 index 0000000..df21437 --- /dev/null +++ b/contracts/libraries/ProfileLib.sol @@ -0,0 +1,360 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {GeneralHelpers} from './helpers/GeneralHelpers.sol'; +import {MetaTxHelpers} from './helpers/MetaTxHelpers.sol'; +import {DataTypes} from './DataTypes.sol'; +import {Errors} from './Errors.sol'; +import {Events} from './Events.sol'; +import {IFollowModule} from '../interfaces/IFollowModule.sol'; +import './Constants.sol'; + +library ProfileLib { + /** + * @notice Creates a profile with the given parameters to the given address. Minting happens + * in the hub. + * + * @param vars The CreateProfileData struct containing the following parameters: + * to: The address receiving the profile. + * imageURI: The URI to set for the profile image. + * followModule: The follow module to use, can be the zero address. + * followModuleInitData: The follow module initialization data, if any + * followNFTURI: The URI to set for the follow NFT. + * @param profileId The profile ID to associate with this profile NFT (token ID). + */ + function createProfile(DataTypes.CreateProfileData calldata vars, uint256 profileId) external { + _validateProfileCreatorWhitelisted(); + + if (bytes(vars.imageURI).length > MAX_PROFILE_IMAGE_URI_LENGTH) + revert Errors.ProfileImageURILengthInvalid(); + + _setProfileString(profileId, PROFILE_IMAGE_URI_OFFSET, vars.imageURI); + _setProfileString(profileId, PROFILE_FOLLOW_NFT_URI_OFFSET, vars.followNFTURI); + + bytes memory followModuleReturnData; + if (vars.followModule != address(0)) { + // Load the follow module to be used in the next assembly block. + address followModule = vars.followModule; + + // Store the follow module for the new profile. We opt not to use the + // _setFollowModule() private function to avoid unnecessary checks. + assembly { + mstore(0, profileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + let slot := add(keccak256(0, 64), PROFILE_FOLLOW_MODULE_OFFSET) + sstore(slot, followModule) + } + + // @note We don't need to check for deprecated modules here because deprecated modules + // are no longer whitelisted. + // Initialize the follow module. + followModuleReturnData = _initFollowModule( + profileId, + vars.to, + vars.followModule, + vars.followModuleInitData + ); + } + emit Events.ProfileCreated( + profileId, + msg.sender, + vars.to, + vars.imageURI, + vars.followModule, + followModuleReturnData, + vars.followNFTURI, + block.timestamp + ); + } + + /** + * @notice Sets the profile image URI for a given profile. + * + * @param profileId The profile ID. + * @param imageURI The image URI to set. + + */ + function setProfileImageURI(uint256 profileId, string calldata imageURI) external { + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(profileId); + _setProfileImageURI(profileId, imageURI); + } + + /** + * @notice Sets the profile image URI via signature for a given profile. + * + * @param vars the SetProfileImageURIWithSigData struct containing the relevant parameters. + */ + function setProfileImageURIWithSig(DataTypes.SetProfileImageURIWithSigData calldata vars) + external + { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + MetaTxHelpers.baseSetProfileImageURIWithSig(signer, vars); + _setProfileImageURI(vars.profileId, vars.imageURI); + } + + /** + * @notice Sets the follow NFT URI for a given profile. + * + * @param profileId The profile ID. + * @param followNFTURI The follow NFT URI to set. + */ + function setFollowNFTURI(uint256 profileId, string calldata followNFTURI) external { + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(profileId); + _setFollowNFTURI(profileId, followNFTURI); + } + + /** + * @notice Sets the follow NFT URI via signature for a given profile. + * + * @param vars the SetFollowNFTURIWithSigData struct containing the relevant parameters. + */ + function setFollowNFTURIWithSig(DataTypes.SetFollowNFTURIWithSigData calldata vars) external { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + MetaTxHelpers.baseSetFollowNFTURIWithSig(signer, vars); + _setFollowNFTURI(vars.profileId, vars.followNFTURI); + } + + /** + * @notice Sets the follow module for a given profile. + * + * @param profileId The profile ID to set the follow module for. + * @param followModule The follow module to set for the given profile, if any. + * @param followModuleInitData The data to pass to the follow module for profile initialization. + */ + function setFollowModule( + uint256 profileId, + address followModule, + bytes calldata followModuleInitData + ) external { + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(profileId); + _setFollowModule(profileId, msg.sender, followModule, followModuleInitData); + } + + /** + * @notice Sets the dispatcher for a given profile via signature. + * + * @param vars the setDispatcherWithSigData struct containing the relevant parameters. + */ + function setDispatcherWithSig(DataTypes.SetDispatcherWithSigData calldata vars) external { + MetaTxHelpers.baseSetDispatcherWithSig(vars); + uint256 profileId = vars.profileId; + address dispatcher = vars.dispatcher; + + // Store the dispatcher in the appropriate slot for the given profile ID. + assembly { + mstore(0, profileId) + mstore(32, DISPATCHER_BY_PROFILE_MAPPING_SLOT) + let slot := keccak256(0, 64) + sstore(slot, dispatcher) + } + emit Events.DispatcherSet(profileId, dispatcher, block.timestamp); + } + + /** + * @notice sets the follow module via signature for a given profile. + * + * @param vars the SetFollowModuleWithSigData struct containing the relevant parameters. + */ + function setFollowModuleWithSig(DataTypes.SetFollowModuleWithSigData calldata vars) external { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + MetaTxHelpers.baseSetFollowModuleWithSig(signer, vars); + _setFollowModule(vars.profileId, signer, vars.followModule, vars.followModuleInitData); + } + + function setProfileMetadataURI(uint256 profileId, string calldata metadataURI) external { + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(profileId); + _setProfileMetadataURI(profileId, metadataURI); + } + + function setProfileMetadataURIWithSig(DataTypes.SetProfileMetadataURIWithSigData calldata vars) + external + { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + MetaTxHelpers.baseSetProfileMetadataURIWithSig(signer, vars); + _setProfileMetadataURI(vars.profileId, vars.metadataURI); + } + + function _setProfileString( + uint256 profileId, + uint256 profileOffset, + string calldata value + ) private { + assembly { + let length := value.length + let cdOffset := value.offset + mstore(0, profileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + let slot := add(keccak256(0, 64), profileOffset) + + // If the length is greater than 31, storage rules are different. + switch gt(length, 31) + case 1 { + // The length is > 31, so we need to store the actual string in a new slot, + // equivalent to keccak256(startSlot), and store length*2+1 in startSlot. + sstore(slot, add(shl(1, length), 1)) + + // Calculate the amount of storage slots we need to store the full string. + // This is equivalent to (string.length + 31)/32. + let totalStorageSlots := shr(5, add(length, 31)) + + // Compute the slot where the actual string will begin, which is the keccak256 + // hash of the slot where we stored the modified length. + mstore(0, slot) + slot := keccak256(0, 32) + + // Write the actual string to storage starting at the computed slot. + // prettier-ignore + for { let i := 0 } lt(i, totalStorageSlots) { i := add(i, 1) } { + sstore(add(slot, i), calldataload(add(cdOffset, mul(32, i)))) + } + } + default { + // The length is <= 31 so store the string and the length*2 in the same slot. + sstore(slot, or(calldataload(cdOffset), shl(1, length))) + } + } + } + + function _setProfileMetadataURI(uint256 profileId, string calldata metadataURI) private { + assembly { + let length := metadataURI.length + let cdOffset := metadataURI.offset + mstore(0, profileId) + mstore(32, PROFILE_METADATA_MAPPING_SLOT) + let slot := keccak256(0, 64) + + // If the length is greater than 31, storage rules are different. + switch gt(length, 31) + case 1 { + // The length is > 31, so we need to store the actual string in a new slot, + // equivalent to keccak256(startSlot), and store length*2+1 in startSlot. + sstore(slot, add(shl(1, length), 1)) + + // Calculate the amount of storage slots we need to store the full string. + // This is equivalent to (string.length + 31)/32. + let totalStorageSlots := shr(5, add(length, 31)) + + // Compute the slot where the actual string will begin, which is the keccak256 + // hash of the slot where we stored the modified length. + mstore(0, slot) + slot := keccak256(0, 32) + + // Write the actual string to storage starting at the computed slot. + // prettier-ignore + for { let i := 0 } lt(i, totalStorageSlots) { i := add(i, 1) } { + sstore(add(slot, i), calldataload(add(cdOffset, mul(32, i)))) + } + } + default { + // The length is <= 31 so store the string and the length*2 in the same slot. + sstore(slot, or(calldataload(cdOffset), shl(1, length))) + } + } + emit Events.ProfileMetadataSet(profileId, metadataURI, block.timestamp); + } + + function _setFollowModule( + uint256 profileId, + address executor, + address followModule, + bytes calldata followModuleInitData + ) private { + // Store the follow module in the appropriate slot for the given profile ID, but + // only if it is not the same as the previous follow module. + assembly { + mstore(0, profileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + let slot := add(keccak256(0, 64), PROFILE_FOLLOW_MODULE_OFFSET) + let currentFollowModule := sload(slot) + if iszero(eq(followModule, currentFollowModule)) { + sstore(slot, followModule) + } + } + + // Initialize the follow module if it is non-zero. + bytes memory followModuleReturnData; + if (followModule != address(0)) + followModuleReturnData = _initFollowModule( + profileId, + executor, + followModule, + followModuleInitData + ); + emit Events.FollowModuleSet( + profileId, + followModule, + followModuleReturnData, + block.timestamp + ); + } + + function _initFollowModule( + uint256 profileId, + address executor, + address followModule, + bytes memory followModuleInitData + ) private returns (bytes memory) { + _validateFollowModuleWhitelisted(followModule); + return + IFollowModule(followModule).initializeFollowModule( + profileId, + executor, + followModuleInitData + ); + } + + function _setProfileImageURI(uint256 profileId, string calldata imageURI) private { + if (bytes(imageURI).length > MAX_PROFILE_IMAGE_URI_LENGTH) + revert Errors.ProfileImageURILengthInvalid(); + _setProfileString(profileId, PROFILE_IMAGE_URI_OFFSET, imageURI); + emit Events.ProfileImageURISet(profileId, imageURI, block.timestamp); + } + + function _setFollowNFTURI(uint256 profileId, string calldata followNFTURI) private { + _setProfileString(profileId, PROFILE_FOLLOW_NFT_URI_OFFSET, followNFTURI); + emit Events.FollowNFTURISet(profileId, followNFTURI, block.timestamp); + } + + function _validateFollowModuleWhitelisted(address followModule) private view { + bool whitelist; + + // Load whether the given follow module is whitelisted. + assembly { + mstore(0, followModule) + mstore(32, FOLLOW_MODULE_WHITELIST_MAPPING_SLOT) + let slot := keccak256(0, 64) + whitelist := sload(slot) + } + if (!whitelist) revert Errors.FollowModuleNotWhitelisted(); + } + + function _validateProfileCreatorWhitelisted() private view { + bool whitelisted; + + // Load whether the caller is whitelisted as a profile creator. + assembly { + mstore(0, caller()) + mstore(32, PROFILE_CREATOR_WHITELIST_MAPPING_SLOT) + let slot := keccak256(0, 64) + whitelisted := sload(slot) + } + if (!whitelisted) revert Errors.ProfileCreatorNotWhitelisted(); + } +} diff --git a/contracts/libraries/ProfileTokenURILogic.sol b/contracts/libraries/ProfileTokenURILogic.sol index bb55c99..f79d4ff 100644 --- a/contracts/libraries/ProfileTokenURILogic.sol +++ b/contracts/libraries/ProfileTokenURILogic.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import '@openzeppelin/contracts/utils/Base64.sol'; import '@openzeppelin/contracts/utils/Strings.sol'; diff --git a/contracts/libraries/PublishingLib.sol b/contracts/libraries/PublishingLib.sol new file mode 100644 index 0000000..4caceb8 --- /dev/null +++ b/contracts/libraries/PublishingLib.sol @@ -0,0 +1,657 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {GeneralHelpers} from './helpers/GeneralHelpers.sol'; +import {MetaTxHelpers} from './helpers/MetaTxHelpers.sol'; +import {DataTypes} from './DataTypes.sol'; +import {Events} from './Events.sol'; +import {Errors} from './Errors.sol'; +import {ICollectModule} from '../interfaces/ICollectModule.sol'; +import {IReferenceModule} from '../interfaces/IReferenceModule.sol'; +import {IDeprecatedReferenceModule} from '../interfaces/IDeprecatedReferenceModule.sol'; +import './Constants.sol'; + +library PublishingLib { + /** + * @notice Publishes a post to a given profile. + * + * @param vars The PostData struct. + * + * @return uint256 The created publication's pubId. + */ + function post(DataTypes.PostData calldata vars) external returns (uint256) { + uint256 pubId = _preIncrementPubCount(vars.profileId); + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(vars.profileId); + _createPost( + vars.profileId, + msg.sender, + pubId, + vars.contentURI, + vars.collectModule, + vars.collectModuleInitData, + vars.referenceModule, + vars.referenceModuleInitData + ); + return pubId; + } + + /** + * @notice Publishes a post to a given profile via signature. + * + * @param vars the PostWithSigData struct. + * + * @return uint256 The created publication's pubId. + */ + function postWithSig(DataTypes.PostWithSigData calldata vars) external returns (uint256) { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + uint256 pubId = _preIncrementPubCount(profileId); + MetaTxHelpers.basePostWithSig(signer, vars); + _createPost( + profileId, + signer, + pubId, + vars.contentURI, + vars.collectModule, + vars.collectModuleInitData, + vars.referenceModule, + vars.referenceModuleInitData + ); + return pubId; + } + + /** + * @notice Publishes a comment to a given profile via signature. + * + * @param vars the CommentData struct. + * + * @return uint256 The created publication's pubId. + */ + function comment(DataTypes.CommentData calldata vars) external returns (uint256) { + uint256 pubId = _preIncrementPubCount(vars.profileId); + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(vars.profileId); + GeneralHelpers.validateNotBlocked(vars.profileId, vars.profileIdPointed); + _createComment(vars, pubId); // caller is executor + return pubId; + } + + /** + * @notice Publishes a comment to a given profile via signature. + * + * @param vars the CommentWithSigData struct. + * + * @return uint256 The created publication's pubId. + */ + function commentWithSig(DataTypes.CommentWithSigData calldata vars) external returns (uint256) { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + uint256 pubId = _preIncrementPubCount(profileId); + GeneralHelpers.validateNotBlocked(vars.profileId, vars.profileIdPointed); + MetaTxHelpers.baseCommentWithSig(signer, vars); + _createCommentWithSigStruct(vars, signer, pubId); + return pubId; + } + + /** + * @notice Publishes a mirror to a given profile. + * + * @param vars the MirrorData struct. + * + * @return uint256 The created publication's pubId. + */ + function mirror(DataTypes.MirrorData calldata vars) external returns (uint256) { + uint256 pubId = _preIncrementPubCount(vars.profileId); + GeneralHelpers.validateCallerIsOwnerOrDispatcherOrExecutor(vars.profileId); + GeneralHelpers.validateNotBlocked(vars.profileId, vars.profileIdPointed); + _createMirror(vars, pubId); // caller is executor + return pubId; + } + + /** + * @notice Publishes a mirror to a given profile via signature. + * + * @param vars the MirrorWithSigData struct. + * + * @return uint256 The created publication's pubId. + */ + function mirrorWithSig(DataTypes.MirrorWithSigData calldata vars) external returns (uint256) { + uint256 profileId = vars.profileId; + address signer = GeneralHelpers.getOriginatorOrDelegatedExecutorSigner( + GeneralHelpers.unsafeOwnerOf(profileId), + vars.delegatedSigner + ); + uint256 pubId = _preIncrementPubCount(profileId); + GeneralHelpers.validateNotBlocked(vars.profileId, vars.profileIdPointed); + MetaTxHelpers.baseMirrorWithSig(signer, vars); + _createMirrorWithSigStruct(vars, signer, pubId); + return pubId; + } + + function _preIncrementPubCount(uint256 profileId) private returns (uint256) { + uint256 pubCount; + // Load the previous publication count for the given profile and increment it in storage. + assembly { + mstore(0, profileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + // pubCount is at offset 0, so we don't need to add any offset. + let slot := keccak256(0, 64) + pubCount := add(sload(slot), 1) + sstore(slot, pubCount) + } + return pubCount; + } + + function _setPublicationPointer( + uint256 profileId, + uint256 pubId, + uint256 profileIdPointed, + uint256 pubIdPointed + ) private { + // Store the pointed profile ID and pointed pub ID in the appropriate slots for + // a given publication. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + // profile ID pointed is at offset 0, so we don't need to add any offset. + let slot := keccak256(0, 64) + sstore(slot, profileIdPointed) + slot := add(slot, PUBLICATION_PUB_ID_POINTED_OFFSET) + sstore(slot, pubIdPointed) + } + } + + function _setPublicationContentURI( + uint256 profileId, + uint256 pubId, + string calldata value + ) private { + assembly { + let length := value.length + let cdOffset := value.offset + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + let slot := add(keccak256(0, 64), PUBLICATION_CONTENT_URI_OFFSET) + + // If the length is greater than 31, storage rules are different. + switch gt(length, 31) + case 1 { + // The length is > 31, so we need to store the actual string in a new slot, + // equivalent to keccak256(startSlot), and store length*2+1 in startSlot. + sstore(slot, add(shl(1, length), 1)) + + // Calculate the amount of storage slots we need to store the full string. + // This is equivalent to (string.length + 31)/32. + let totalStorageSlots := shr(5, add(length, 31)) + + // Compute the slot where the actual string will begin, which is the keccak256 + // hash of the slot where we stored the modified length. + mstore(0, slot) + slot := keccak256(0, 32) + + // Write the actual string to storage starting at the computed slot. + // prettier-ignore + for { let i := 0 } lt(i, totalStorageSlots) { i := add(i, 1) } { + sstore(add(slot, i), calldataload(add(cdOffset, mul(32, i)))) + } + } + default { + // The length is <= 31 so store the string and the length*2 in the same slot. + sstore(slot, or(calldataload(cdOffset), shl(1, length))) + } + } + } + + /** + * @notice Creates a post publication mapped to the given profile. + * + * @param profileId The profile ID to associate this publication to. + * @param executor The executor, which is either the owner or an approved delegated executor. + * @param pubId The publication ID to associate with this publication. + * @param contentURI The URI to set for this publication. + * @param collectModule The collect module to set for this publication. + * @param collectModuleInitData The data to pass to the collect module for publication initialization. + * @param referenceModule The reference module to set for this publication, if any. + * @param referenceModuleInitData The data to pass to the reference module for publication initialization. + */ + function _createPost( + uint256 profileId, + address executor, + uint256 pubId, + string calldata contentURI, + address collectModule, + bytes calldata collectModuleInitData, + address referenceModule, + bytes calldata referenceModuleInitData + ) private { + _setPublicationContentURI(profileId, pubId, contentURI); + + bytes memory collectModuleReturnData = _initPubCollectModule( + profileId, + executor, + pubId, + collectModule, + collectModuleInitData + ); + + bytes memory referenceModuleReturnData = _initPubReferenceModule( + profileId, + executor, + pubId, + referenceModule, + referenceModuleInitData + ); + + emit Events.PostCreated( + profileId, + pubId, + contentURI, + collectModule, + collectModuleReturnData, + referenceModule, + referenceModuleReturnData, + block.timestamp + ); + } + + /** + * @notice Creates a comment publication mapped to the given profile. + * + * @param vars The CommentData struct to use to create the comment. + * @param pubId The publication ID to associate with this publication. + */ + function _createComment(DataTypes.CommentData calldata vars, uint256 pubId) private { + uint256 pubCountPointed = _getPubCount(vars.profileIdPointed); + if (pubCountPointed < vars.pubIdPointed || vars.pubIdPointed == 0) + revert Errors.PublicationDoesNotExist(); + + if (vars.profileId == vars.profileIdPointed && vars.pubIdPointed == pubId) + revert Errors.CannotCommentOnSelf(); + + _setPublicationPointer(vars.profileId, pubId, vars.profileIdPointed, vars.pubIdPointed); + _setPublicationContentURI(vars.profileId, pubId, vars.contentURI); + + bytes memory collectModuleReturnData = _initPubCollectModule( + vars.profileId, + msg.sender, + pubId, + vars.collectModule, + vars.collectModuleInitData + ); + + bytes memory referenceModuleReturnData = _initPubReferenceModule( + vars.profileId, + msg.sender, + pubId, + vars.referenceModule, + vars.referenceModuleInitData + ); + + _processCommentIfNeeded( + vars.profileId, + msg.sender, + vars.profileIdPointed, + vars.pubIdPointed, + vars.referenceModuleData + ); + + emit Events.CommentCreated( + vars.profileId, + pubId, + vars.contentURI, + vars.profileIdPointed, + vars.pubIdPointed, + vars.referenceModuleData, + vars.collectModule, + collectModuleReturnData, + vars.referenceModule, + referenceModuleReturnData, + block.timestamp + ); + } + + /** + * @notice Creates a comment publication mapped to the given profile with a sig struct. + * + * @param vars The CommentWithSigData struct to use to create the comment. + * @param executor The publisher or an approved delegated executor. + * @param pubId The publication ID to associate with this publication. + */ + function _createCommentWithSigStruct( + DataTypes.CommentWithSigData calldata vars, + address executor, + uint256 pubId + ) private { + // Prevents stack too deep. + { + uint256 pubCountPointed = _getPubCount(vars.profileIdPointed); + if (pubCountPointed < vars.pubIdPointed || vars.pubIdPointed == 0) + revert Errors.PublicationDoesNotExist(); + } + + if (vars.profileId == vars.profileIdPointed && vars.pubIdPointed == pubId) + revert Errors.CannotCommentOnSelf(); + + _setPublicationPointer(vars.profileId, pubId, vars.profileIdPointed, vars.pubIdPointed); + _setPublicationContentURI(vars.profileId, pubId, vars.contentURI); + + bytes memory collectModuleReturnData = _initPubCollectModule( + vars.profileId, + executor, + pubId, + vars.collectModule, + vars.collectModuleInitData + ); + + bytes memory referenceModuleReturnData = _initPubReferenceModule( + vars.profileId, + executor, + pubId, + vars.referenceModule, + vars.referenceModuleInitData + ); + + _processCommentIfNeeded( + vars.profileId, + executor, + vars.profileIdPointed, + vars.pubIdPointed, + vars.referenceModuleData + ); + + emit Events.CommentCreated( + vars.profileId, + pubId, + vars.contentURI, + vars.profileIdPointed, + vars.pubIdPointed, + vars.referenceModuleData, + vars.collectModule, + collectModuleReturnData, + vars.referenceModule, + referenceModuleReturnData, + block.timestamp + ); + } + + /** + * @notice Creates a mirror publication mapped to the given profile. + * + * @param vars The MirrorData struct to use to create the mirror. + * @param pubId The publication ID to associate with this publication. + */ + function _createMirror(DataTypes.MirrorData calldata vars, uint256 pubId) private { + (uint256 rootProfileIdPointed, uint256 rootPubIdPointed) = GeneralHelpers + .getPointedIfMirror(vars.profileIdPointed, vars.pubIdPointed); + + _setPublicationPointer(vars.profileId, pubId, rootProfileIdPointed, rootPubIdPointed); + + bytes memory referenceModuleReturnData = _initPubReferenceModule( + vars.profileId, + msg.sender, + pubId, + vars.referenceModule, + vars.referenceModuleInitData + ); + + _processMirrorIfNeeded( + vars.profileId, + msg.sender, + rootProfileIdPointed, + rootPubIdPointed, + vars.referenceModuleData + ); + + emit Events.MirrorCreated( + vars.profileId, + pubId, + rootProfileIdPointed, + rootPubIdPointed, + vars.referenceModuleData, + vars.referenceModule, + referenceModuleReturnData, + block.timestamp + ); + } + + /** + * @notice Creates a mirror publication mapped to the given profile using a sig struct. + * + * @param vars The MirrorWithSigData struct to use to create the mirror. + * @param executor The publisher or an approved delegated executor. + * @param pubId The publication ID to associate with this publication. + */ + function _createMirrorWithSigStruct( + DataTypes.MirrorWithSigData calldata vars, + address executor, + uint256 pubId + ) private { + (uint256 rootProfileIdPointed, uint256 rootPubIdPointed) = GeneralHelpers + .getPointedIfMirror(vars.profileIdPointed, vars.pubIdPointed); + + _setPublicationPointer(vars.profileId, pubId, rootProfileIdPointed, rootPubIdPointed); + + bytes memory referenceModuleReturnData = _initPubReferenceModule( + vars.profileId, + executor, + pubId, + vars.referenceModule, + vars.referenceModuleInitData + ); + + _processMirrorIfNeeded( + vars.profileId, + executor, + rootProfileIdPointed, + rootPubIdPointed, + vars.referenceModuleData + ); + + emit Events.MirrorCreated( + vars.profileId, + pubId, + rootProfileIdPointed, + rootPubIdPointed, + vars.referenceModuleData, + vars.referenceModule, + referenceModuleReturnData, + block.timestamp + ); + } + + function _validateCollectModuleWhitelisted(address collectModule) private view { + bool whitelisted; + + // Load whether the given collect module is whitelisted. + assembly { + mstore(0, collectModule) + mstore(32, COLLECT_MODULE_WHITELIST_MAPPING_SLOT) + let slot := keccak256(0, 64) + whitelisted := sload(slot) + } + if (!whitelisted) revert Errors.CollectModuleNotWhitelisted(); + } + + function _validateReferenceModuleWhitelisted(address referenceModule) private view { + bool whitelisted; + + // Load whether the given reference module is whitelisted. + assembly { + mstore(0, referenceModule) + mstore(32, REFERENCE_MODULE_WHITELIST_MAPPING_SLOT) + let slot := keccak256(0, 64) + whitelisted := sload(slot) + } + if (!whitelisted) revert Errors.ReferenceModuleNotWhitelisted(); + } + + function _processCommentIfNeeded( + uint256 profileId, + address executor, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata referenceModuleData + ) private { + address refModule = _getReferenceModule(profileIdPointed, pubIdPointed); + if (refModule != address(0)) { + try + IReferenceModule(refModule).processComment( + profileId, + executor, + profileIdPointed, + pubIdPointed, + referenceModuleData + ) + {} catch (bytes memory err) { + assembly { + /// Equivalent to reverting with the returned error selector if + /// the length is not zero. + let length := mload(err) + if iszero(iszero(length)) { + revert(add(err, 32), length) + } + } + if (executor != GeneralHelpers.unsafeOwnerOf(profileId)) + revert Errors.ExecutorInvalid(); + IDeprecatedReferenceModule(refModule).processComment( + profileId, + profileIdPointed, + pubIdPointed, + referenceModuleData + ); + } + } + } + + function _processMirrorIfNeeded( + uint256 profileId, + address executor, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata referenceModuleData + ) private { + address refModule = _getReferenceModule(profileIdPointed, pubIdPointed); + if (refModule != address(0)) { + try + IReferenceModule(refModule).processMirror( + profileId, + executor, + profileIdPointed, + pubIdPointed, + referenceModuleData + ) + {} catch (bytes memory err) { + assembly { + /// Equivalent to reverting with the returned error selector if + /// the length is not zero. + let length := mload(err) + if iszero(iszero(length)) { + revert(add(err, 32), length) + } + } + if (executor != GeneralHelpers.unsafeOwnerOf(profileId)) + revert Errors.ExecutorInvalid(); + IDeprecatedReferenceModule(refModule).processMirror( + profileId, + profileIdPointed, + pubIdPointed, + referenceModuleData + ); + } + } + } + + function _initPubCollectModule( + uint256 profileId, + address executor, + uint256 pubId, + address collectModule, + bytes memory collectModuleInitData + ) private returns (bytes memory) { + _validateCollectModuleWhitelisted(collectModule); + + // Store the collect module in the appropriate slot for the given publication. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + let slot := add(keccak256(0, 64), PUBLICATION_COLLECT_MODULE_OFFSET) + sstore(slot, collectModule) + } + return + ICollectModule(collectModule).initializePublicationCollectModule( + profileId, + executor, + pubId, + collectModuleInitData + ); + } + + function _initPubReferenceModule( + uint256 profileId, + address executor, + uint256 pubId, + address referenceModule, + bytes memory referenceModuleInitData + ) private returns (bytes memory) { + if (referenceModule == address(0)) return new bytes(0); + _validateReferenceModuleWhitelisted(referenceModule); + + // Store the reference module in the appropriate slot for the given publication. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + let slot := add(keccak256(0, 64), PUBLICATION_REFERENCE_MODULE_OFFSET) + sstore(slot, referenceModule) + } + return + IReferenceModule(referenceModule).initializeReferenceModule( + profileId, + executor, + pubId, + referenceModuleInitData + ); + } + + function _getPubCount(uint256 profileId) private view returns (uint256) { + uint256 pubCount; + + // Load the publication count for the given profile. + assembly { + mstore(0, profileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + // pubCount is at offset 0, so we don't need to add any offset. + let slot := keccak256(0, 64) + pubCount := sload(slot) + } + return pubCount; + } + + function _getReferenceModule(uint256 profileId, uint256 pubId) private view returns (address) { + address referenceModule; + + // Load the reference module for the given publication. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + let slot := add(keccak256(0, 64), PUBLICATION_REFERENCE_MODULE_OFFSET) + referenceModule := sload(slot) + } + return referenceModule; + } +} diff --git a/contracts/libraries/PublishingLogic.sol b/contracts/libraries/PublishingLogic.sol deleted file mode 100644 index d8a60ac..0000000 --- a/contracts/libraries/PublishingLogic.sol +++ /dev/null @@ -1,411 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.10; - -import {Helpers} from './Helpers.sol'; -import {DataTypes} from './DataTypes.sol'; -import {Errors} from './Errors.sol'; -import {Events} from './Events.sol'; -import {Constants} from './Constants.sol'; -import {IFollowModule} from '../interfaces/IFollowModule.sol'; -import {ICollectModule} from '../interfaces/ICollectModule.sol'; -import {IReferenceModule} from '../interfaces/IReferenceModule.sol'; - -/** - * @title PublishingLogic - * @author Lens Protocol - * - * @notice This is the library that contains the logic for profile creation & publication. - * - * @dev The functions are external, so they are called from the hub via `delegateCall` under the hood. Furthermore, - * expected events are emitted from this library instead of from the hub to alleviate code size concerns. - */ -library PublishingLogic { - /** - * @notice Executes the logic to create a profile with the given parameters to the given address. - * - * @param vars The CreateProfileData struct containing the following parameters: - * to: The address receiving the profile. - * handle: The handle to set for the profile, must be unique and non-empty. - * imageURI: The URI to set for the profile image. - * followModule: The follow module to use, can be the zero address. - * followModuleInitData: The follow module initialization data, if any - * followNFTURI: The URI to set for the follow NFT. - * @param profileId The profile ID to associate with this profile NFT (token ID). - * @param _profileIdByHandleHash The storage reference to the mapping of profile IDs by handle hash. - * @param _profileById The storage reference to the mapping of profile structs by IDs. - * @param _followModuleWhitelisted The storage reference to the mapping of whitelist status by follow module address. - */ - function createProfile( - DataTypes.CreateProfileData calldata vars, - uint256 profileId, - mapping(bytes32 => uint256) storage _profileIdByHandleHash, - mapping(uint256 => DataTypes.ProfileStruct) storage _profileById, - mapping(address => bool) storage _followModuleWhitelisted - ) external { - _validateHandle(vars.handle); - - if (bytes(vars.imageURI).length > Constants.MAX_PROFILE_IMAGE_URI_LENGTH) - revert Errors.ProfileImageURILengthInvalid(); - - bytes32 handleHash = keccak256(bytes(vars.handle)); - - if (_profileIdByHandleHash[handleHash] != 0) revert Errors.HandleTaken(); - - _profileIdByHandleHash[handleHash] = profileId; - _profileById[profileId].handle = vars.handle; - _profileById[profileId].imageURI = vars.imageURI; - _profileById[profileId].followNFTURI = vars.followNFTURI; - - bytes memory followModuleReturnData; - if (vars.followModule != address(0)) { - _profileById[profileId].followModule = vars.followModule; - followModuleReturnData = _initFollowModule( - profileId, - vars.followModule, - vars.followModuleInitData, - _followModuleWhitelisted - ); - } - - _emitProfileCreated(profileId, vars, followModuleReturnData); - } - - /** - * @notice Sets the follow module for a given profile. - * - * @param profileId The profile ID to set the follow module for. - * @param followModule The follow module to set for the given profile, if any. - * @param followModuleInitData The data to pass to the follow module for profile initialization. - * @param _profile The storage reference to the profile struct associated with the given profile ID. - * @param _followModuleWhitelisted The storage reference to the mapping of whitelist status by follow module address. - */ - function setFollowModule( - uint256 profileId, - address followModule, - bytes calldata followModuleInitData, - DataTypes.ProfileStruct storage _profile, - mapping(address => bool) storage _followModuleWhitelisted - ) external { - if (followModule != _profile.followModule) { - _profile.followModule = followModule; - } - - bytes memory followModuleReturnData; - if (followModule != address(0)) - followModuleReturnData = _initFollowModule( - profileId, - followModule, - followModuleInitData, - _followModuleWhitelisted - ); - emit Events.FollowModuleSet( - profileId, - followModule, - followModuleReturnData, - block.timestamp - ); - } - - /** - * @notice Creates a post publication mapped to the given profile. - * - * @dev To avoid a stack too deep error, reference parameters are passed in memory rather than calldata. - * - * @param profileId The profile ID to associate this publication to. - * @param contentURI The URI to set for this publication. - * @param collectModule The collect module to set for this publication. - * @param collectModuleInitData The data to pass to the collect module for publication initialization. - * @param referenceModule The reference module to set for this publication, if any. - * @param referenceModuleInitData The data to pass to the reference module for publication initialization. - * @param pubId The publication ID to associate with this publication. - * @param _pubByIdByProfile The storage reference to the mapping of publications by publication ID by profile ID. - * @param _collectModuleWhitelisted The storage reference to the mapping of whitelist status by collect module address. - * @param _referenceModuleWhitelisted The storage reference to the mapping of whitelist status by reference module address. - */ - function createPost( - uint256 profileId, - string memory contentURI, - address collectModule, - bytes memory collectModuleInitData, - address referenceModule, - bytes memory referenceModuleInitData, - uint256 pubId, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(address => bool) storage _collectModuleWhitelisted, - mapping(address => bool) storage _referenceModuleWhitelisted - ) external { - _pubByIdByProfile[profileId][pubId].contentURI = contentURI; - - // Collect module initialization - bytes memory collectModuleReturnData = _initPubCollectModule( - profileId, - pubId, - collectModule, - collectModuleInitData, - _pubByIdByProfile, - _collectModuleWhitelisted - ); - - // Reference module initialization - bytes memory referenceModuleReturnData = _initPubReferenceModule( - profileId, - pubId, - referenceModule, - referenceModuleInitData, - _pubByIdByProfile, - _referenceModuleWhitelisted - ); - - emit Events.PostCreated( - profileId, - pubId, - contentURI, - collectModule, - collectModuleReturnData, - referenceModule, - referenceModuleReturnData, - block.timestamp - ); - } - - /** - * @notice Creates a comment publication mapped to the given profile. - * - * @dev This function is unique in that it requires many variables, so, unlike the other publishing functions, - * we need to pass the full CommentData struct in memory to avoid a stack too deep error. - * - * @param vars The CommentData struct to use to create the comment. - * @param pubId The publication ID to associate with this publication. - * @param _profileById The storage reference to the mapping of profile structs by IDs. - * @param _pubByIdByProfile The storage reference to the mapping of publications by publication ID by profile ID. - * @param _collectModuleWhitelisted The storage reference to the mapping of whitelist status by collect module address. - * @param _referenceModuleWhitelisted The storage reference to the mapping of whitelist status by reference module address. - */ - function createComment( - DataTypes.CommentData memory vars, - uint256 pubId, - mapping(uint256 => DataTypes.ProfileStruct) storage _profileById, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(address => bool) storage _collectModuleWhitelisted, - mapping(address => bool) storage _referenceModuleWhitelisted - ) external { - // Validate existence of the pointed publication - uint256 pubCount = _profileById[vars.profileIdPointed].pubCount; - if (pubCount < vars.pubIdPointed || vars.pubIdPointed == 0) - revert Errors.PublicationDoesNotExist(); - - // Ensure the pointed publication is not the comment being created - if (vars.profileId == vars.profileIdPointed && vars.pubIdPointed == pubId) - revert Errors.CannotCommentOnSelf(); - - _pubByIdByProfile[vars.profileId][pubId].contentURI = vars.contentURI; - _pubByIdByProfile[vars.profileId][pubId].profileIdPointed = vars.profileIdPointed; - _pubByIdByProfile[vars.profileId][pubId].pubIdPointed = vars.pubIdPointed; - - // Collect Module Initialization - bytes memory collectModuleReturnData = _initPubCollectModule( - vars.profileId, - pubId, - vars.collectModule, - vars.collectModuleInitData, - _pubByIdByProfile, - _collectModuleWhitelisted - ); - - // Reference module initialization - bytes memory referenceModuleReturnData = _initPubReferenceModule( - vars.profileId, - pubId, - vars.referenceModule, - vars.referenceModuleInitData, - _pubByIdByProfile, - _referenceModuleWhitelisted - ); - - // Reference module validation - address refModule = _pubByIdByProfile[vars.profileIdPointed][vars.pubIdPointed] - .referenceModule; - if (refModule != address(0)) { - IReferenceModule(refModule).processComment( - vars.profileId, - vars.profileIdPointed, - vars.pubIdPointed, - vars.referenceModuleData - ); - } - - // Prevents a stack too deep error - _emitCommentCreated(vars, pubId, collectModuleReturnData, referenceModuleReturnData); - } - - /** - * @notice Creates a mirror publication mapped to the given profile. - * - * @param vars The MirrorData struct to use to create the mirror. - * @param pubId The publication ID to associate with this publication. - * @param _pubByIdByProfile The storage reference to the mapping of publications by publication ID by profile ID. - * @param _referenceModuleWhitelisted The storage reference to the mapping of whitelist status by reference module address. - */ - function createMirror( - DataTypes.MirrorData memory vars, - uint256 pubId, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(address => bool) storage _referenceModuleWhitelisted - ) external { - (uint256 rootProfileIdPointed, uint256 rootPubIdPointed, ) = Helpers.getPointedIfMirror( - vars.profileIdPointed, - vars.pubIdPointed, - _pubByIdByProfile - ); - - _pubByIdByProfile[vars.profileId][pubId].profileIdPointed = rootProfileIdPointed; - _pubByIdByProfile[vars.profileId][pubId].pubIdPointed = rootPubIdPointed; - - // Reference module initialization - bytes memory referenceModuleReturnData = _initPubReferenceModule( - vars.profileId, - pubId, - vars.referenceModule, - vars.referenceModuleInitData, - _pubByIdByProfile, - _referenceModuleWhitelisted - ); - - // Reference module validation - address refModule = _pubByIdByProfile[rootProfileIdPointed][rootPubIdPointed] - .referenceModule; - if (refModule != address(0)) { - IReferenceModule(refModule).processMirror( - vars.profileId, - rootProfileIdPointed, - rootPubIdPointed, - vars.referenceModuleData - ); - } - - emit Events.MirrorCreated( - vars.profileId, - pubId, - rootProfileIdPointed, - rootPubIdPointed, - vars.referenceModuleData, - vars.referenceModule, - referenceModuleReturnData, - block.timestamp - ); - } - - function _initPubCollectModule( - uint256 profileId, - uint256 pubId, - address collectModule, - bytes memory collectModuleInitData, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(address => bool) storage _collectModuleWhitelisted - ) private returns (bytes memory) { - if (!_collectModuleWhitelisted[collectModule]) revert Errors.CollectModuleNotWhitelisted(); - _pubByIdByProfile[profileId][pubId].collectModule = collectModule; - return - ICollectModule(collectModule).initializePublicationCollectModule( - profileId, - pubId, - collectModuleInitData - ); - } - - function _initPubReferenceModule( - uint256 profileId, - uint256 pubId, - address referenceModule, - bytes memory referenceModuleInitData, - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) - storage _pubByIdByProfile, - mapping(address => bool) storage _referenceModuleWhitelisted - ) private returns (bytes memory) { - if (referenceModule == address(0)) return new bytes(0); - if (!_referenceModuleWhitelisted[referenceModule]) - revert Errors.ReferenceModuleNotWhitelisted(); - _pubByIdByProfile[profileId][pubId].referenceModule = referenceModule; - return - IReferenceModule(referenceModule).initializeReferenceModule( - profileId, - pubId, - referenceModuleInitData - ); - } - - function _initFollowModule( - uint256 profileId, - address followModule, - bytes memory followModuleInitData, - mapping(address => bool) storage _followModuleWhitelisted - ) private returns (bytes memory) { - if (!_followModuleWhitelisted[followModule]) revert Errors.FollowModuleNotWhitelisted(); - return IFollowModule(followModule).initializeFollowModule(profileId, followModuleInitData); - } - - function _emitCommentCreated( - DataTypes.CommentData memory vars, - uint256 pubId, - bytes memory collectModuleReturnData, - bytes memory referenceModuleReturnData - ) private { - emit Events.CommentCreated( - vars.profileId, - pubId, - vars.contentURI, - vars.profileIdPointed, - vars.pubIdPointed, - vars.referenceModuleData, - vars.collectModule, - collectModuleReturnData, - vars.referenceModule, - referenceModuleReturnData, - block.timestamp - ); - } - - function _emitProfileCreated( - uint256 profileId, - DataTypes.CreateProfileData calldata vars, - bytes memory followModuleReturnData - ) internal { - emit Events.ProfileCreated( - profileId, - msg.sender, // Creator is always the msg sender - vars.to, - vars.handle, - vars.imageURI, - vars.followModule, - followModuleReturnData, - vars.followNFTURI, - block.timestamp - ); - } - - function _validateHandle(string calldata handle) private pure { - bytes memory byteHandle = bytes(handle); - if (byteHandle.length == 0 || byteHandle.length > Constants.MAX_HANDLE_LENGTH) - revert Errors.HandleLengthInvalid(); - - uint256 byteHandleLength = byteHandle.length; - for (uint256 i = 0; i < byteHandleLength; ) { - if ( - (byteHandle[i] < '0' || - byteHandle[i] > 'z' || - (byteHandle[i] > '9' && byteHandle[i] < 'a')) && - byteHandle[i] != '.' && - byteHandle[i] != '-' && - byteHandle[i] != '_' - ) revert Errors.HandleContainsInvalidCharacters(); - unchecked { - ++i; - } - } - } -} diff --git a/contracts/libraries/helpers/GeneralHelpers.sol b/contracts/libraries/helpers/GeneralHelpers.sol new file mode 100644 index 0000000..0f1ec4b --- /dev/null +++ b/contracts/libraries/helpers/GeneralHelpers.sol @@ -0,0 +1,253 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {DataTypes} from '../DataTypes.sol'; +import {Errors} from '../Errors.sol'; + +import '../Constants.sol'; + +/** + * @title Helpers + * @author Lens Protocol + * + * @notice This is a library that contains helper internal functions used by both the Hub and the GeneralLib. + */ +library GeneralHelpers { + /** + * @notice This helper function just returns the pointed publication if the passed publication is a mirror, + * otherwise it returns the passed publication. + * + * @param profileId The token ID of the profile that published the given publication. + * @param pubId The publication ID of the given publication. + * + * @return tuple First, the pointed publication's publishing profile ID, and second, the pointed publication's ID. + * If the passed publication is not a mirror, this returns the given publication. + */ + function getPointedIfMirror(uint256 profileId, uint256 pubId) + internal + view + returns (uint256, uint256) + { + uint256 slot; + address collectModule; + + // Load the collect module for the given profile (zero if it is a mirror) and cache the + // publication storage slot. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + slot := keccak256(0, 64) + let collectModuleSlot := add(slot, PUBLICATION_COLLECT_MODULE_OFFSET) + collectModule := sload(collectModuleSlot) + } + + if (collectModule != address(0)) { + return (profileId, pubId); + } else { + uint256 profileIdPointed; + + // Load the pointed profile ID, first in the cached slot. + assembly { + // profile ID pointed is at offset 0, so we don't need to add any offset. + profileIdPointed := sload(slot) + } + + // We validate existence here as an optimization, so validating in calling + // contracts is unnecessary. + if (profileIdPointed == 0) revert Errors.PublicationDoesNotExist(); + + uint256 pubIdPointed; + + // Load the pointed publication ID for the given publication. + assembly { + let pointedPubIdSlot := add(slot, PUBLICATION_PUB_ID_POINTED_OFFSET) + pubIdPointed := sload(pointedPubIdSlot) + } + return (profileIdPointed, pubIdPointed); + } + } + + /** + * @notice This helper function just returns the pointed publication if the passed publication is a mirror, + * otherwise it returns the passed publication. + * + * @param profileId The token ID of the profile that published the given publication. + * @param pubId The publication ID of the given publication. + * + * @return tuple First, the pointed publication's publishing profile ID, second, the pointed publication's ID, and third, the + * pointed publication's collect module. If the passed publication is not a mirror, this returns the given publication. + */ + function getPointedIfMirrorWithCollectModule(uint256 profileId, uint256 pubId) + internal + view + returns ( + uint256, + uint256, + address + ) + { + uint256 slot; + address collectModule; + + // Load the collect module for the given profile (zero if it is a mirror) and cache the + // publication storage slot. + assembly { + mstore(0, profileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubId) + slot := keccak256(0, 64) + let collectModuleSlot := add(slot, PUBLICATION_COLLECT_MODULE_OFFSET) + collectModule := sload(collectModuleSlot) + } + + if (collectModule != address(0)) { + return (profileId, pubId, collectModule); + } else { + uint256 profileIdPointed; + + // Load the pointed profile ID, first in the cached slot. + assembly { + // profile ID pointed is at offset 0, so we don't need to add any offset. + profileIdPointed := sload(slot) + } + + // We validate existence here as an optimization, so validating in calling + // contracts is unnecessary. + if (profileIdPointed == 0) revert Errors.PublicationDoesNotExist(); + + uint256 pubIdPointed; + address collectModulePointed; + + // Load the pointed publication ID and the pointed collect module for the given + // publication. + assembly { + let pointedPubIdSlot := add(slot, PUBLICATION_PUB_ID_POINTED_OFFSET) + pubIdPointed := sload(pointedPubIdSlot) + + mstore(0, profileIdPointed) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, pubIdPointed) + slot := add(keccak256(0, 64), PUBLICATION_COLLECT_MODULE_OFFSET) + collectModulePointed := sload(slot) + } + return (profileIdPointed, pubIdPointed, collectModulePointed); + } + } + + /** + * @dev This fetches the owner address for a given token ID. Note that this does not check and + * revert upon loading a zero address. + * + * However, this function is only used if the result is compared to the caller or a recovered signer, + * which is already checked for the zero address. + */ + function unsafeOwnerOf(uint256 tokenId) internal view returns (address) { + address owner; + assembly { + mstore(0, tokenId) + mstore(32, TOKEN_DATA_MAPPING_SLOT) + let slot := keccak256(0, 64) + // This bit shift is necessary to remove the packing from the variable. + owner := shr(96, shl(96, sload(slot))) + } + return owner; + } + + function ownerOf(uint256 tokenId) internal view returns (address) { + address owner = unsafeOwnerOf(tokenId); + if (owner == address(0)) { + revert Errors.TokenDoesNotExist(); + } + return owner; + } + + function validateCallerIsOwnerOrDispatcherOrExecutor(uint256 profileId) internal view { + // It's safe to use the `unsafeOwnerOf()` function here because the sender cannot be + // the zero address, the dispatcher is cleared on burn and the zero address cannot approve + // a delegated executor. + address owner = unsafeOwnerOf(profileId); + if (msg.sender != owner) { + address dispatcher; + + // Load the dispatcher for the given profile. + assembly { + mstore(0, profileId) + mstore(32, DISPATCHER_BY_PROFILE_MAPPING_SLOT) + let slot := keccak256(0, 64) + dispatcher := sload(slot) + } + if (msg.sender == dispatcher) return; + validateDelegatedExecutor(owner, msg.sender); + } + } + + function validateCallerIsOwnerOrDelegatedExecutor(uint256 profileId) internal view { + address owner = ownerOf(profileId); + if (msg.sender != owner) { + validateDelegatedExecutor(owner, msg.sender); + } + } + + function validateAddressIsOwnerOrDelegatedExecutor( + address transactionExecutor, + address profileOwner + ) internal view { + if (transactionExecutor != profileOwner) { + validateDelegatedExecutor(profileOwner, transactionExecutor); + } + } + + function validateDelegatedExecutor(address onBehalfOf, address executor) internal view { + if (!isExecutorApproved(onBehalfOf, executor)) { + revert Errors.ExecutorInvalid(); + } + } + + function isExecutorApproved(address onBehalfOf, address executor) internal view returns (bool) { + bool isExecutorApproved; + assembly { + mstore(0, onBehalfOf) + mstore(32, DELEGATED_EXECUTOR_APPROVAL_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, executor) + let slot := keccak256(0, 64) + isExecutorApproved := sload(slot) + } + return isExecutorApproved; + } + + /** + * @dev Returns either the profile owner or the delegated signer if valid. + */ + function getOriginatorOrDelegatedExecutorSigner(address originator, address delegatedSigner) + internal + view + returns (address) + { + if (delegatedSigner != address(0)) { + validateDelegatedExecutor(originator, delegatedSigner); + return delegatedSigner; + } + return originator; + } + + function validateNotBlocked(uint256 profile, uint256 byProfile) internal view { + bool isBlocked; + assembly { + mstore(0, byProfile) + mstore(32, BLOCK_STATUS_MAPPING_SLOT) + let blockStatusByProfileSlot := keccak256(0, 64) + mstore(0, profile) + mstore(32, blockStatusByProfileSlot) + isBlocked := sload(keccak256(0, 64)) + } + if (isBlocked) { + revert Errors.Blocked(); + } + } +} diff --git a/contracts/libraries/helpers/InteractionHelpers.sol b/contracts/libraries/helpers/InteractionHelpers.sol new file mode 100644 index 0000000..f2804c9 --- /dev/null +++ b/contracts/libraries/helpers/InteractionHelpers.sol @@ -0,0 +1,432 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {FollowNFTProxy} from '../../upgradeability/FollowNFTProxy.sol'; +import {GeneralHelpers} from './GeneralHelpers.sol'; +import {DataTypes} from '../DataTypes.sol'; +import {Errors} from '../Errors.sol'; +import {Events} from '../Events.sol'; +import {IFollowNFT} from '../../interfaces/IFollowNFT.sol'; +import {ICollectNFT} from '../../interfaces/ICollectNFT.sol'; +import {IFollowModule} from '../../interfaces/IFollowModule.sol'; +import {ICollectModule} from '../../interfaces/ICollectModule.sol'; +import {IReferenceModule} from '../../interfaces/IReferenceModule.sol'; +import {IDeprecatedFollowModule} from '../../interfaces/IDeprecatedFollowModule.sol'; +import {IDeprecatedCollectModule} from '../../interfaces/IDeprecatedCollectModule.sol'; +import {IDeprecatedReferenceModule} from '../../interfaces/IDeprecatedReferenceModule.sol'; +import {Clones} from '@openzeppelin/contracts/proxy/Clones.sol'; +import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; + +import '../Constants.sol'; + +/** + * @title InteractionHelpers + * @author Lens Protocol + * + * @notice This is the library used by the GeneralLib that contains the logic for follows & collects. + * + * @dev The functions are internal, so they are inlined into the GeneralLib. + */ +library InteractionHelpers { + using Strings for uint256; + + function follow( + uint256 followerProfileId, + address executor, + uint256[] calldata idsOfProfilesToFollow, + uint256[] calldata followTokenIds, + bytes[] calldata followModuleDatas + ) internal returns (uint256[] memory) { + if ( + idsOfProfilesToFollow.length != followTokenIds.length || + idsOfProfilesToFollow.length != followModuleDatas.length + ) { + revert Errors.ArrayMismatch(); + } + uint256[] memory followTokenIdsAssigned = new uint256[](idsOfProfilesToFollow.length); + uint256 i; + while (i < idsOfProfilesToFollow.length) { + _validateProfileExists({profileId: idsOfProfilesToFollow[i]}); + + GeneralHelpers.validateNotBlocked({ + profile: followerProfileId, + byProfile: idsOfProfilesToFollow[i] + }); + + if (followerProfileId == idsOfProfilesToFollow[i]) { + revert Errors.SelfFollow(); + } + + followTokenIdsAssigned[i] = _follow({ + followerProfileId: followerProfileId, + executor: executor, + idOfProfileToFollow: idsOfProfilesToFollow[i], + followTokenId: followTokenIds[i], + followModuleData: followModuleDatas[i] + }); + + unchecked { + ++i; + } + } + return followTokenIdsAssigned; + } + + function unfollow( + uint256 unfollowerProfileId, + address executor, + uint256[] calldata idsOfProfilesToUnfollow + ) internal { + uint256 i; + while (i < idsOfProfilesToUnfollow.length) { + uint256 idOfProfileToUnfollow = idsOfProfilesToUnfollow[i]; + _validateProfileExists(idOfProfileToUnfollow); + + address followNFT; + // Load the Follow NFT for the profile being unfollowed. + assembly { + mstore(0, idOfProfileToUnfollow) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + let followNFTSlot := add(keccak256(0, 64), PROFILE_FOLLOW_NFT_OFFSET) + followNFT := sload(followNFTSlot) + } + + if (followNFT == address(0)) { + revert Errors.NotFollowing(); + } + + IFollowNFT(followNFT).unfollow({ + unfollowerProfileId: unfollowerProfileId, + executor: executor + }); + + emit Events.Unfollowed(unfollowerProfileId, idOfProfileToUnfollow, block.timestamp); + + unchecked { + ++i; + } + } + } + + function setBlockStatus( + uint256 byProfileId, + uint256[] calldata idsOfProfilesToSetBlockStatus, + bool[] calldata blockStatus + ) internal { + if (idsOfProfilesToSetBlockStatus.length != blockStatus.length) { + revert Errors.ArrayMismatch(); + } + uint256 blockStatusByProfileSlot; + // Calculates the slot of the block status internal mapping once accessed by `byProfileId`. + // i.e. the slot of `_blockedStatus[byProfileId]` + assembly { + mstore(0, byProfileId) + mstore(32, BLOCK_STATUS_MAPPING_SLOT) + blockStatusByProfileSlot := keccak256(0, 64) + } + address followNFT; + // Loads the Follow NFT address from storage. + // i.e. `followNFT = _profileById[byProfileId].followNFT;` + assembly { + mstore(0, byProfileId) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + followNFT := sload(add(keccak256(0, 64), PROFILE_FOLLOW_NFT_OFFSET)) + } + uint256 i; + uint256 idOfProfileToSetBlockStatus; + bool setToBlocked; + while (i < idsOfProfilesToSetBlockStatus.length) { + idOfProfileToSetBlockStatus = idsOfProfilesToSetBlockStatus[i]; + _validateProfileExists(idOfProfileToSetBlockStatus); + if (byProfileId == idOfProfileToSetBlockStatus) { + revert Errors.SelfBlock(); + } + setToBlocked = blockStatus[i]; + if (followNFT != address(0) && setToBlocked) { + IFollowNFT(followNFT).processBlock(idOfProfileToSetBlockStatus); + } + // Stores the block status. + // i.e. `_blockedStatus[byProfileId][idOfProfileToSetBlockStatus] = setToBlocked;` + assembly { + mstore(0, idOfProfileToSetBlockStatus) + mstore(32, blockStatusByProfileSlot) + sstore(keccak256(0, 64), setToBlocked) + } + if (setToBlocked) { + emit Events.Blocked(byProfileId, idOfProfileToSetBlockStatus, block.timestamp); + } else { + emit Events.Unblocked(byProfileId, idOfProfileToSetBlockStatus, block.timestamp); + } + unchecked { + ++i; + } + } + } + + function collect( + uint256 collectorProfileId, + address collectorProfileOwner, + address transactionExecutor, // TODO: (ex-delegatedExecutor) - revisit the naming later + uint256 publisherProfileId, + uint256 pubId, + bytes calldata collectModuleData, + address collectNFTImpl + ) internal returns (uint256) { + uint256 publisherProfileIdCached = publisherProfileId; + uint256 pubIdCached = pubId; + uint256 collectorProfileIdCached = collectorProfileId; + address collectorProfileOwnerCached = collectorProfileOwner; + address transactionExecutorCached = transactionExecutor; + + GeneralHelpers.validateAddressIsOwnerOrDelegatedExecutor({ + transactionExecutor: transactionExecutor, + profileOwner: collectorProfileOwner + }); + + GeneralHelpers.validateNotBlocked(collectorProfileId, publisherProfileId); + + (uint256 rootProfileId, uint256 rootPubId, address rootCollectModule) = GeneralHelpers + .getPointedIfMirrorWithCollectModule(publisherProfileIdCached, pubIdCached); + + // Prevents stack too deep. + address collectNFT; + { + uint256 collectNFTSlot; + + // Load the collect NFT and for the given publication being collected, and cache the + // collect NFT slot. + assembly { + mstore(0, rootProfileId) + mstore(32, PUB_BY_ID_BY_PROFILE_MAPPING_SLOT) + mstore(32, keccak256(0, 64)) + mstore(0, rootPubId) + collectNFTSlot := add(keccak256(0, 64), PUBLICATION_COLLECT_NFT_OFFSET) + collectNFT := sload(collectNFTSlot) + } + + if (collectNFT == address(0)) { + collectNFT = _deployCollectNFT(rootProfileId, rootPubId, collectNFTImpl); + + // Store the collect NFT in the cached slot. + assembly { + sstore(collectNFTSlot, collectNFT) + } + } + } + + uint256 tokenId = ICollectNFT(collectNFT).mint(collectorProfileOwnerCached); + _processCollect( + ProcessCollectVars({ + collectModule: rootCollectModule, + publisherProfileId: publisherProfileIdCached, + collectorProfileId: collectorProfileIdCached, + collectorProfileOwner: collectorProfileOwnerCached, + transactionExecutor: transactionExecutorCached, + rootProfileId: rootProfileId, + rootPubId: rootPubId, + pubId: pubIdCached + }), + collectModuleData + ); + + return tokenId; + } + + // TODO: Think about how to make this better... (it's needed for stack too deep) + struct ProcessCollectVars { + address collectModule; + uint256 publisherProfileId; + uint256 collectorProfileId; + address collectorProfileOwner; + address transactionExecutor; + uint256 rootProfileId; + uint256 rootPubId; + uint256 pubId; + } + + function _processCollect(ProcessCollectVars memory vars, bytes calldata collectModuleData) + private + { + try + ICollectModule(vars.collectModule).processCollect( + vars.publisherProfileId, + vars.collectorProfileId, + vars.collectorProfileOwner, + vars.transactionExecutor, + vars.rootProfileId, + vars.rootPubId, + collectModuleData + ) + {} catch (bytes memory err) { + assembly { + /// Equivalent to reverting with the returned error selector if + /// the length is not zero. + let length := mload(err) + if iszero(iszero(length)) { + revert(add(err, 32), length) + } + } + if (vars.collectorProfileOwner != vars.transactionExecutor) + revert Errors.ExecutorInvalid(); + IDeprecatedCollectModule(vars.collectModule).processCollect( + vars.publisherProfileId, + vars.collectorProfileOwner, + vars.rootProfileId, + vars.rootPubId, + collectModuleData + ); + } + + _emitCollectedEvent( + vars.collectorProfileId, + vars.publisherProfileId, + vars.pubId, + vars.rootProfileId, + vars.rootPubId, + collectModuleData + ); + } + + /** + * @notice Deploys the given profile's Collect NFT contract. + * + * @param profileId The token ID of the profile which Collect NFT should be deployed. + * @param pubId The publication ID of the publication being collected, which Collect NFT should be deployed. + * @param collectNFTImpl The address of the Collect NFT implementation that should be used for the deployment. + * + * @return address The address of the deployed Collect NFT contract. + */ + function _deployCollectNFT( + uint256 profileId, + uint256 pubId, + address collectNFTImpl + ) private returns (address) { + address collectNFT = Clones.clone(collectNFTImpl); + + string memory collectNFTName = string( + abi.encodePacked(profileId.toString(), COLLECT_NFT_NAME_INFIX, pubId.toString()) + ); + string memory collectNFTSymbol = string( + abi.encodePacked(profileId.toString(), COLLECT_NFT_SYMBOL_INFIX, pubId.toString()) + ); + + ICollectNFT(collectNFT).initialize(profileId, pubId, collectNFTName, collectNFTSymbol); + emit Events.CollectNFTDeployed(profileId, pubId, collectNFT, block.timestamp); + + return collectNFT; + } + + /** + * @notice Emits the `Collected` event that signals that a successful collect action has occurred. + * + * @dev This is done through this function to prevent stack too deep compilation error. + * + * @param collectorProfileId The owner address of the profile collecting the publication. + * @param publisherProfileId The token ID of the profile that the collect was initiated towards, useful to differentiate mirrors. + * @param pubId The publication ID that the collect was initiated towards, useful to differentiate mirrors. + * @param rootProfileId The profile token ID of the profile whose publication is being collected. + * @param rootPubId The publication ID of the publication being collected. + * @param data The data passed to the collect module. + */ + function _emitCollectedEvent( + uint256 collectorProfileId, + uint256 publisherProfileId, + uint256 pubId, + uint256 rootProfileId, + uint256 rootPubId, + bytes calldata data + ) private { + emit Events.Collected( + collectorProfileId, + publisherProfileId, + pubId, + rootProfileId, + rootPubId, + data, + block.timestamp + ); + } + + function _follow( + uint256 followerProfileId, + address executor, + uint256 idOfProfileToFollow, + uint256 followTokenId, + bytes calldata followModuleData + ) internal returns (uint256) { + uint256 followNFTSlot; + address followModule; + address followNFT; + + // Load the follow NFT and follow module for the given profile being followed, and cache + // the follow NFT slot. + assembly { + mstore(0, idOfProfileToFollow) + mstore(32, PROFILE_BY_ID_MAPPING_SLOT) + // The follow NFT offset is 2, the follow module offset is 1, + // so we just need to subtract 1 instead of recalculating the slot. + followNFTSlot := add(keccak256(0, 64), PROFILE_FOLLOW_NFT_OFFSET) + followModule := sload(sub(followNFTSlot, 1)) + followNFT := sload(followNFTSlot) + } + + if (followNFT == address(0)) { + followNFT = _deployFollowNFT(idOfProfileToFollow); + + // Store the follow NFT in the cached slot. + assembly { + sstore(followNFTSlot, followNFT) + } + } + + uint256 followTokenIdAssigned = IFollowNFT(followNFT).follow({ + followerProfileId: followerProfileId, + executor: executor, + followTokenId: followTokenId + }); + + if (followModule != address(0)) { + IFollowModule(followModule).processFollow( + followerProfileId, + followTokenId, + executor, + idOfProfileToFollow, + followModuleData + ); + } + + emit Events.Followed( + followerProfileId, + idOfProfileToFollow, + followTokenIdAssigned, + followModuleData, + block.timestamp + ); + + return followTokenIdAssigned; + } + + /** + * @notice Deploys the given profile's Follow NFT contract. + * + * @param profileId The token ID of the profile which Follow NFT should be deployed. + * + * @return address The address of the deployed Follow NFT contract. + */ + function _deployFollowNFT(uint256 profileId) private returns (address) { + bytes memory functionData = abi.encodeWithSelector( + IFollowNFT.initialize.selector, + profileId + ); + address followNFT = address(new FollowNFTProxy(functionData)); + emit Events.FollowNFTDeployed(profileId, followNFT, block.timestamp); + + return followNFT; + } + + function _validateProfileExists(uint256 profileId) private view { + if (GeneralHelpers.unsafeOwnerOf(profileId) == address(0)) + revert Errors.TokenDoesNotExist(); + } +} diff --git a/contracts/libraries/helpers/MetaTxHelpers.sol b/contracts/libraries/helpers/MetaTxHelpers.sol new file mode 100644 index 0000000..7b6fa49 --- /dev/null +++ b/contracts/libraries/helpers/MetaTxHelpers.sol @@ -0,0 +1,592 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.15; + +import {IEIP1271Implementer} from '../../interfaces/IEIP1271Implementer.sol'; +import {DataTypes} from '../DataTypes.sol'; +import {Errors} from '../Errors.sol'; +import {DataTypes} from '../DataTypes.sol'; +import {GeneralHelpers} from './GeneralHelpers.sol'; +import '../Constants.sol'; + +/** + * @title MetaTxHelpers + * @author Lens Protocol + * + * @notice This is the library used by the GeneralLib that contains the logic for signature + * validation. + * + * NOTE: the baseFunctions in this contract operate under the assumption that the passed signer is already validated + * to either be the originator or one of their delegated executors. + * + * @dev The functions are internal, so they are inlined into the GeneralLib. User nonces + * are incremented from this library as well. + */ +library MetaTxHelpers { + /// Permit and PermitForAll emit these ERC721 events here an optimization. + event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); + event ApprovalForAll(address indexed owner, address indexed operator, bool approved); + + /** + * @notice Validates parameters and increments the nonce for a given owner using the `permit()` + * function. + * + * @param spender The spender to approve. + * @param tokenId The token ID to approve the spender for. + * @param sig the EIP712Signature struct containing the token owner's signature. + */ + function basePermit( + address spender, + uint256 tokenId, + DataTypes.EIP712Signature calldata sig + ) internal { + if (spender == address(0)) revert Errors.ZeroSpender(); + address owner = GeneralHelpers.unsafeOwnerOf(tokenId); + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode(PERMIT_TYPEHASH, spender, tokenId, _sigNonces(owner), sig.deadline) + ) + ), + owner, + sig + ); + emit Approval(owner, spender, tokenId); + } + + function basePermitForAll( + address owner, + address operator, + bool approved, + DataTypes.EIP712Signature calldata sig + ) internal { + if (operator == address(0)) revert Errors.ZeroSpender(); + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + PERMIT_FOR_ALL_TYPEHASH, + owner, + operator, + approved, + _sigNonces(owner), + sig.deadline + ) + ) + ), + owner, + sig + ); + emit ApprovalForAll(owner, operator, approved); + } + + function baseSetDefaultProfileWithSig( + address signer, + DataTypes.SetDefaultProfileWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH, + vars.wallet, + vars.profileId, + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseSetProfileMetadataURIWithSig( + address signer, + DataTypes.SetProfileMetadataURIWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_PROFILE_METADATA_URI_WITH_SIG_TYPEHASH, + vars.profileId, + keccak256(bytes(vars.metadataURI)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseSetFollowModuleWithSig( + address signer, + DataTypes.SetFollowModuleWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH, + vars.profileId, + vars.followModule, + keccak256(vars.followModuleInitData), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseSetDispatcherWithSig(DataTypes.SetDispatcherWithSigData calldata vars) internal { + address owner = GeneralHelpers.unsafeOwnerOf(vars.profileId); + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_DISPATCHER_WITH_SIG_TYPEHASH, + vars.profileId, + vars.dispatcher, + _sigNonces(owner), + vars.sig.deadline + ) + ) + ), + owner, + vars.sig + ); + } + + function baseSetDelegatedExecutorApprovalWithSig( + DataTypes.SetDelegatedExecutorApprovalWithSigData calldata vars + ) internal { + address onBehalfOf = vars.onBehalfOf; + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_DELEGATED_EXECUTOR_APPROVAL_WITH_SIG_TYPEHASH, + vars.onBehalfOf, + vars.executor, + vars.approved, + _sigNonces(onBehalfOf), + vars.sig.deadline + ) + ) + ), + onBehalfOf, + vars.sig + ); + } + + function baseSetProfileImageURIWithSig( + address signer, + DataTypes.SetProfileImageURIWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH, + vars.profileId, + keccak256(bytes(vars.imageURI)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseSetFollowNFTURIWithSig( + address signer, + DataTypes.SetFollowNFTURIWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_FOLLOW_NFT_URI_WITH_SIG_TYPEHASH, + vars.profileId, + keccak256(bytes(vars.followNFTURI)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function basePostWithSig(address signer, DataTypes.PostWithSigData calldata vars) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + POST_WITH_SIG_TYPEHASH, + vars.profileId, + keccak256(bytes(vars.contentURI)), + vars.collectModule, + keccak256(vars.collectModuleInitData), + vars.referenceModule, + keccak256(vars.referenceModuleInitData), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseCommentWithSig(address signer, DataTypes.CommentWithSigData calldata vars) + internal + { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + COMMENT_WITH_SIG_TYPEHASH, + vars.profileId, + keccak256(bytes(vars.contentURI)), + vars.profileIdPointed, + vars.pubIdPointed, + keccak256(vars.referenceModuleData), + vars.collectModule, + keccak256(vars.collectModuleInitData), + vars.referenceModule, + keccak256(vars.referenceModuleInitData), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseMirrorWithSig(address signer, DataTypes.MirrorWithSigData calldata vars) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + MIRROR_WITH_SIG_TYPEHASH, + vars.profileId, + vars.profileIdPointed, + vars.pubIdPointed, + keccak256(vars.referenceModuleData), + vars.referenceModule, + keccak256(vars.referenceModuleInitData), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseBurnWithSig(uint256 tokenId, DataTypes.EIP712Signature calldata sig) internal { + address owner = GeneralHelpers.unsafeOwnerOf(tokenId); + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode(BURN_WITH_SIG_TYPEHASH, tokenId, _sigNonces(owner), sig.deadline) + ) + ), + owner, + sig + ); + } + + function baseFollowWithSig(address signer, DataTypes.FollowWithSigData calldata vars) internal { + uint256 dataLength = vars.datas.length; + bytes32[] memory dataHashes = new bytes32[](dataLength); + for (uint256 i = 0; i < dataLength; ) { + dataHashes[i] = keccak256(vars.datas[i]); + unchecked { + ++i; + } + } + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + FOLLOW_WITH_SIG_TYPEHASH, + vars.followerProfileId, + keccak256(abi.encodePacked(vars.idsOfProfilesToFollow)), + keccak256(abi.encodePacked(vars.followTokenIds)), + keccak256(abi.encodePacked(dataHashes)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseUnfollowWithSig(address signer, DataTypes.UnfollowWithSigData calldata vars) + internal + { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + UNFOLLOW_WITH_SIG_TYPEHASH, + vars.unfollowerProfileId, + keccak256(abi.encodePacked(vars.idsOfProfilesToUnfollow)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseSetBlockStatusWithSig( + address signer, + DataTypes.SetBlockStatusWithSigData calldata vars + ) internal { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + SET_BLOCK_STATUS_WITH_SIG_TYPEHASH, + vars.byProfileId, + keccak256(abi.encodePacked(vars.idsOfProfilesToSetBlockStatus)), + keccak256(abi.encodePacked(vars.blockStatus)), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function baseCollectWithSig(address signer, DataTypes.CollectWithSigData calldata vars) + internal + { + _validateRecoveredAddress( + _calculateDigest( + keccak256( + abi.encode( + COLLECT_WITH_SIG_TYPEHASH, + vars.collectorProfileId, + vars.publisherProfileId, + vars.pubId, + keccak256(vars.data), + _sigNonces(signer), + vars.sig.deadline + ) + ) + ), + signer, + vars.sig + ); + } + + function getDomainSeparator() internal view returns (bytes32) { + return _calculateDomainSeparator(); + } + + /** + * @dev Wrapper for ecrecover to reduce code size, used in meta-tx specific functions. + */ + function _validateRecoveredAddress( + bytes32 digest, + address expectedAddress, + DataTypes.EIP712Signature calldata sig + ) internal view { + if (sig.deadline < block.timestamp) revert Errors.SignatureExpired(); + // If the expected address is a contract, check the signature there. + if (expectedAddress.code.length != 0) { + bytes memory concatenatedSig = abi.encodePacked(sig.r, sig.s, sig.v); + if ( + IEIP1271Implementer(expectedAddress).isValidSignature(digest, concatenatedSig) != + EIP1271_MAGIC_VALUE + ) { + revert Errors.SignatureInvalid(); + } + } else { + address recoveredAddress = ecrecover(digest, sig.v, sig.r, sig.s); + if (recoveredAddress == address(0) || recoveredAddress != expectedAddress) { + revert Errors.SignatureInvalid(); + } + } + } + + // /** + // * @dev Wrapper for ecrecover to reduce code size, used in meta-tx specific functions. + // */ + // function _validateRecoveredAddressWithExecutor( + // bytes32 digest, + // address expectedAddress, + // DataTypes.EIP712Signature calldata sig + // ) internal view { + // if (sig.deadline < block.timestamp) revert Errors.SignatureExpired(); + // address recoveredAddress = expectedAddress; + // // If the expected address is a contract, check the signature there. + // if (recoveredAddress.code.length != 0) { + // bytes memory concatenatedSig = abi.encodePacked(sig.r, sig.s, sig.v); + // if ( + // IEIP1271Implementer(expectedAddress).isValidSignature(digest, concatenatedSig) != + // EIP1271_MAGIC_VALUE + // ) revert Errors.SignatureInvalid(); + // } else { + // recoveredAddress = ecrecover(digest, sig.v, sig.r, sig.s); + // if (recoveredAddress == address(0)) revert Errors.SignatureInvalid(); + // // GeneralHelpers.validateOnBehalfOfOrExecutor(expectedAddress, recoveredAddress); + // } + // // Execution passes fine, since either a DE or the expected address is recovered. + // } + + // function _validateRecoveredAddressWithExecutorAndReturn( + // bytes32 digest, + // address expectedAddress, + // DataTypes.EIP712Signature calldata sig + // ) internal view returns (address) { + // if (sig.deadline < block.timestamp) revert Errors.SignatureExpired(); + // address recoveredAddress = expectedAddress; + // // If the expected address is a contract, check the signature there. + // if (recoveredAddress.code.length != 0) { + // bytes memory concatenatedSig = abi.encodePacked(sig.r, sig.s, sig.v); + // if ( + // IEIP1271Implementer(expectedAddress).isValidSignature(digest, concatenatedSig) != + // EIP1271_MAGIC_VALUE + // ) revert Errors.SignatureInvalid(); + // } else { + // recoveredAddress = ecrecover(digest, sig.v, sig.r, sig.s); + // if (recoveredAddress == address(0)) revert Errors.SignatureInvalid(); + // // GeneralHelpers.validateOnBehalfOfOrExecutor(expectedAddress, recoveredAddress); + // } + // // Execution passes fine, since either a DE or the expected address is recovered. + // return recoveredAddress; + // } + + /** + * @dev Calculates EIP712 DOMAIN_SEPARATOR based on the current contract and chain ID. + */ + function _calculateDomainSeparator() private view returns (bytes32) { + if (block.chainid == POLYGON_CHAIN_ID) { + // Note that this only works on the canonical Polygon mainnet deployment, and should the + // name change, a contract upgrade would be necessary. + return POLYGON_DOMAIN_SEPARATOR; + } + return + keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(_nameBytes()), + EIP712_REVISION_HASH, + block.chainid, + address(this) + ) + ); + } + + /** + * @dev Calculates EIP712 digest based on the current DOMAIN_SEPARATOR. + * + * @param hashedMessage The message hash from which the digest should be calculated. + * + * @return bytes32 A 32-byte output representing the EIP712 digest. + */ + function _calculateDigest(bytes32 hashedMessage) private view returns (bytes32) { + bytes32 digest; + unchecked { + digest = keccak256( + abi.encodePacked('\x19\x01', _calculateDomainSeparator(), hashedMessage) + ); + } + return digest; + } + + /** + * @dev This fetches a user's signing nonce and increments it, akin to `sigNonces++`. + * + * @param user The user address to fetch and post-increment the signing nonce for. + * + * @return uint256 The signing nonce for the given user prior to being incremented. + */ + function _sigNonces(address user) private returns (uint256) { + uint256 previousValue; + assembly { + mstore(0, user) + mstore(32, SIG_NONCES_MAPPING_SLOT) + let slot := keccak256(0, 64) + previousValue := sload(slot) + sstore(slot, add(previousValue, 1)) + } + return previousValue; + } + + /** + * @dev Reads the name storage slot and returns the value as a bytes variable. + * + * @return bytes The contract's name. + */ + function _nameBytes() private view returns (bytes memory) { + bytes memory ptr; + assembly { + // Load the free memory pointer, where we'll return the value + ptr := mload(64) + + // Load the slot, which either contains the name + 2*length if length < 32 or + // 2*length+1 if length >= 32, and the actual string starts at slot keccak256(NAME_SLOT) + let slotLoad := sload(NAME_SLOT) + + let size + // Determine if the length > 32 by checking the lowest order bit, meaning the string + // itself is stored at keccak256(NAME_SLOT) + switch and(slotLoad, 1) + case 0 { + // The name is in the same slot + // Determine the size by dividing the last byte's value by 2 + size := shr(1, and(slotLoad, 255)) + + // Store the size in the first slot + mstore(ptr, size) + + // Store the actual string in the second slot (without the size) + mstore(add(ptr, 32), and(slotLoad, not(255))) + } + case 1 { + // The name is not in the same slot + // Determine the size by dividing the value in the whole slot minus 1 by 2 + size := shr(1, sub(slotLoad, 1)) + + // Store the size in the first slot + mstore(ptr, size) + + // Compute the total memory slots we need, this is (size + 31) / 32 + let totalMemorySlots := shr(5, add(size, 31)) + + // Iterate through the words in memory and store the string word by word + // prettier-ignore + for { let i := 0 } lt(i, totalMemorySlots) { i := add(i, 1) } { + mstore(add(add(ptr, 32), mul(32, i)), sload(add(NAME_SLOT_GT_31, i))) + } + } + // Store the new memory pointer in the free memory pointer slot + mstore(64, add(add(ptr, 32), size)) + } + return ptr; + } +} diff --git a/contracts/misc/LensPeriphery.sol b/contracts/misc/LensPeriphery.sol index bd5d068..1ef1389 100644 --- a/contracts/misc/LensPeriphery.sol +++ b/contracts/misc/LensPeriphery.sol @@ -1,8 +1,8 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {IERC721Time} from '../core/base/IERC721Time.sol'; +import {IERC721Time} from '../interfaces/IERC721Time.sol'; import {ILensHub} from '../interfaces/ILensHub.sol'; import {DataTypes} from '../libraries/DataTypes.sol'; import {Events} from '../libraries/Events.sol'; @@ -27,10 +27,6 @@ contract LensPeriphery { keccak256( 'ToggleFollowWithSig(uint256[] profileIds,bool[] enables,uint256 nonce,uint256 deadline)' ); - bytes32 internal constant SET_PROFILE_METADATA_WITH_SIG_TYPEHASH = - keccak256( - 'SetProfileMetadataURIWithSig(uint256 profileId,string metadata,uint256 nonce,uint256 deadline)' - ); ILensHub public immutable HUB; @@ -42,46 +38,6 @@ contract LensPeriphery { HUB = hub; } - /** - * @notice Sets the profile metadata for a given profile. - * - * @param profileId The profile ID to set the metadata for. - * @param metadata The metadata string to set for the profile. - */ - function setProfileMetadataURI(uint256 profileId, string calldata metadata) external { - _validateCallerIsProfileOwnerOrDispatcher(profileId); - _setProfileMetadataURI(profileId, metadata); - } - - /** - * @notice Sets the profile metadata for a given profile via signature with the specified parameters. - * - * @param vars A SetProfileMetadataWithSigData struct containingthe regular parameters and an EIP712Signature struct. - */ - function setProfileMetadataURIWithSig(DataTypes.SetProfileMetadataWithSigData calldata vars) - external - { - unchecked { - address owner = IERC721Time(address(HUB)).ownerOf(vars.profileId); - _validateRecoveredAddress( - _calculateDigest( - keccak256( - abi.encode( - SET_PROFILE_METADATA_WITH_SIG_TYPEHASH, - vars.profileId, - keccak256(bytes(vars.metadata)), - sigNonces[owner]++, - vars.sig.deadline - ) - ) - ), - owner, - vars.sig - ); - } - _setProfileMetadataURI(vars.profileId, vars.metadata); - } - /** * @notice Toggle Follows on the given profiles, emiting toggle event for each FollowNFT. * @@ -122,22 +78,6 @@ contract LensPeriphery { _toggleFollow(vars.follower, vars.profileIds, vars.enables); } - /** - * @notice Returns the metadata URI of a profile. - * - * @param profileId The profile ID to query the metadata URI for. - * - * @return string The metadata associated with that profile ID, or an empty string if it is not set or the profile does not exist. - */ - function getProfileMetadataURI(uint256 profileId) external view returns (string memory) { - return _metadataByProfile[profileId]; - } - - function _setProfileMetadataURI(uint256 profileId, string calldata metadata) internal { - _metadataByProfile[profileId] = metadata; - emit Events.ProfileMetadataSet(profileId, metadata, block.timestamp); - } - function _toggleFollow( address follower, uint256[] calldata profileIds, @@ -164,11 +104,13 @@ contract LensPeriphery { ) { return; } - revert Errors.NotProfileOwnerOrDispatcher(); + revert Errors.NotProfileOwnerOrValid(); } /** * @dev Wrapper for ecrecover to reduce code size, used in meta-tx specific functions. + * + * @notice In order to use the MetaTXHelpers here, we will need to re-deploy. */ function _validateRecoveredAddress( bytes32 digest, diff --git a/contracts/misc/ProfileCreationProxy.sol b/contracts/misc/ProfileCreationProxy.sol index 5d54fa4..de2a7db 100644 --- a/contracts/misc/ProfileCreationProxy.sol +++ b/contracts/misc/ProfileCreationProxy.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ILensHub} from '../interfaces/ILensHub.sol'; import {DataTypes} from '../libraries/DataTypes.sol'; @@ -23,21 +23,6 @@ contract ProfileCreationProxy is Ownable { } function proxyCreateProfile(DataTypes.CreateProfileData memory vars) external onlyOwner { - uint256 handleLength = bytes(vars.handle).length; - if (handleLength < 5) revert Errors.HandleLengthInvalid(); - - bytes1 firstByte = bytes(vars.handle)[0]; - if (firstByte == '-' || firstByte == '_' || firstByte == '.') - revert Errors.HandleFirstCharInvalid(); - - for (uint256 i = 1; i < handleLength; ) { - if (bytes(vars.handle)[i] == '.') revert Errors.HandleContainsInvalidCharacters(); - unchecked { - ++i; - } - } - - vars.handle = string(abi.encodePacked(vars.handle, '.lens')); LENS_HUB.createProfile(vars); } } diff --git a/contracts/misc/UIDataProvider.sol b/contracts/misc/UIDataProvider.sol index 5b35d8d..d1d8acb 100644 --- a/contracts/misc/UIDataProvider.sol +++ b/contracts/misc/UIDataProvider.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ILensHub} from '../interfaces/ILensHub.sol'; import {DataTypes} from '../libraries/DataTypes.sol'; @@ -42,19 +42,4 @@ contract UIDataProvider { uint256 pubCount = profileStruct.pubCount; return LatestData(profileStruct, HUB.getPub(profileId, pubCount)); } - - /** - * @notice Returns the profile struct and latest publication struct associated with the passed - * profile ID. - * - * @param handle The handle to query. - * - * @return LensData A struct containing the `ProfileStruct` and the `PublicationStruct` queried. - */ - function getLatestDataByHandle(string memory handle) external view returns (LatestData memory) { - uint256 profileId = HUB.getProfileIdByHandle(handle); - DataTypes.ProfileStruct memory profileStruct = HUB.getProfile(profileId); - uint256 pubCount = profileStruct.pubCount; - return LatestData(profileStruct, HUB.getPub(profileId, pubCount)); - } } diff --git a/contracts/mocks/BadMockEIP1271Implementer.sol b/contracts/mocks/BadMockEIP1271Implementer.sol new file mode 100644 index 0000000..5898015 --- /dev/null +++ b/contracts/mocks/BadMockEIP1271Implementer.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IEIP1271Implementer} from '../interfaces/IEIP1271Implementer.sol'; + +/** + * @dev This is a mock contract that always returns the wrong value upon being checked with EIP-1271. + */ +contract BadMockEIP1271Implementer is IEIP1271Implementer { + function isValidSignature(bytes32 _hash, bytes memory _signature) + external + view + override + returns (bytes4) + { + return bytes4(0xFFFFFFFF); + } +} diff --git a/contracts/mocks/Currency.sol b/contracts/mocks/Currency.sol index 0bd0f94..e974091 100644 --- a/contracts/mocks/Currency.sol +++ b/contracts/mocks/Currency.sol @@ -1,9 +1,12 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ERC20} from '@openzeppelin/contracts/token/ERC20/ERC20.sol'; +/** + * @dev A simple mock currency to be used for testing. + */ contract Currency is ERC20('Currency', 'CRNC') { function mint(address to, uint256 amount) external { _mint(to, amount); diff --git a/contracts/mocks/Helper.sol b/contracts/mocks/Helper.sol index 9d7f63c..9ee47c2 100644 --- a/contracts/mocks/Helper.sol +++ b/contracts/mocks/Helper.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IFollowNFT} from '../interfaces/IFollowNFT.sol'; @@ -17,16 +17,4 @@ contract Helper { function getBlockNumber() external view returns (uint256) { return block.number; } - - /** - * @dev This is a helper function to aid in testing same-block delegation in the FollowNFT contract. - */ - function batchDelegate( - IFollowNFT nft, - address first, - address second - ) external { - nft.delegate(first); - nft.delegate(second); - } } diff --git a/contracts/mocks/MockCollectModule.sol b/contracts/mocks/MockCollectModule.sol new file mode 100644 index 0000000..9eac846 --- /dev/null +++ b/contracts/mocks/MockCollectModule.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {ICollectModule} from '../interfaces/ICollectModule.sol'; + +/** + * @title FreeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface. + * + * This module works by allowing all collects. + */ +contract MockCollectModule is ICollectModule { + /** + * @dev There is nothing needed at initialization. + */ + function initializePublicationCollectModule( + uint256, + address, + uint256, + bytes calldata data + ) external pure override returns (bytes memory) { + uint256 number = abi.decode(data, (uint256)); + require(number == 1, 'MockCollectModule: invalid'); + return new bytes(0); + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower, if needed + */ + function processCollect( + uint256, + uint256, + address collector, + address, + uint256 profileId, + uint256 pubId, + bytes calldata + ) external view override {} +} diff --git a/contracts/mocks/MockDeprecatedCollectModule.sol b/contracts/mocks/MockDeprecatedCollectModule.sol new file mode 100644 index 0000000..a9658d7 --- /dev/null +++ b/contracts/mocks/MockDeprecatedCollectModule.sol @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedCollectModule} from '../interfaces/IDeprecatedCollectModule.sol'; + +/** + * @title FreeCollectModule + * @author Lens Protocol + * + * @notice This is a simple Lens CollectModule implementation, inheriting from the ICollectModule interface. + * + * This module works by allowing all collects. + */ +contract MockDeprecatedCollectModule is IDeprecatedCollectModule { + /** + * @dev There is nothing needed at initialization. + */ + function initializePublicationCollectModule( + uint256, + uint256, + bytes calldata data + ) external pure override returns (bytes memory) { + uint256 number = abi.decode(data, (uint256)); + require(number == 1, 'MockReferenceModule: invalid'); + return new bytes(0); + } + + /** + * @dev Processes a collect by: + * 1. Ensuring the collector is a follower, if needed + */ + function processCollect( + uint256, + address collector, + uint256 profileId, + uint256 pubId, + bytes calldata + ) external view override {} +} diff --git a/contracts/mocks/MockDeprecatedFollowModule.sol b/contracts/mocks/MockDeprecatedFollowModule.sol new file mode 100644 index 0000000..ba69ff4 --- /dev/null +++ b/contracts/mocks/MockDeprecatedFollowModule.sol @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedFollowModule} from '../interfaces/IDeprecatedFollowModule.sol'; + +/** + * @dev This is a simple mock follow module to be used for testing. + */ +contract MockDeprecatedFollowModule is IDeprecatedFollowModule { + function initializeFollowModule( + uint256, + bytes calldata data + ) external pure override returns (bytes memory) { + uint256 number = abi.decode(data, (uint256)); + require(number == 1, 'MockFollowModule: invalid'); + return new bytes(0); + } + + function processFollow( + address follower, + uint256 profileId, + bytes calldata data + ) external override {} + + function isFollowing( + uint256, + address, + uint256 + ) external pure override returns (bool) { + return true; + } + + function followModuleTransferHook( + uint256 profileId, + address from, + address to, + uint256 followNFTTokenId + ) external override {} +} diff --git a/contracts/mocks/MockDeprecatedReferenceModule.sol b/contracts/mocks/MockDeprecatedReferenceModule.sol new file mode 100644 index 0000000..5c9d880 --- /dev/null +++ b/contracts/mocks/MockDeprecatedReferenceModule.sol @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IDeprecatedReferenceModule} from '../interfaces/IDeprecatedReferenceModule.sol'; + +/** + * @dev This is a simple mock follow module to be used for testing. + */ +contract MockDeprecatedReferenceModule is IDeprecatedReferenceModule { + function initializeReferenceModule( + uint256, + uint256, + bytes calldata data + ) external pure override returns (bytes memory) { + uint256 number = abi.decode(data, (uint256)); + require(number == 1, 'MockDeprecatedReferenceModule: invalid'); + return new bytes(0); + } + + function processComment( + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata data + ) external override {} + + function processMirror( + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes calldata data + ) external override {} +} diff --git a/contracts/mocks/MockEIP1271Implementer.sol b/contracts/mocks/MockEIP1271Implementer.sol new file mode 100644 index 0000000..714dbef --- /dev/null +++ b/contracts/mocks/MockEIP1271Implementer.sol @@ -0,0 +1,47 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IEIP1271Implementer} from '../interfaces/IEIP1271Implementer.sol'; + +/** + * @dev This is a mock contract that validates an EIP1271 signature against its deployer. + */ +contract MockEIP1271Implementer is IEIP1271Implementer { + // bytes4(keccak256("isValidSignature(bytes32,bytes)") + bytes4 internal constant MAGIC_VALUE = 0x1626ba7e; + + address public immutable OWNER; + + constructor() { + OWNER = msg.sender; + } + + function isValidSignature(bytes32 _hash, bytes memory _signature) + external + view + override + returns (bytes4) + { + require(_signature.length == 65, 'Invalid signature length'); + bytes32 r; + bytes32 s; + uint8 v; + + assembly { + r := mload(add(_signature, 32)) + s := mload(add(_signature, 64)) + v := shr(248, mload(add(_signature, 96))) + } + + // (bytes32 r, bytes32 s, uint8 v) = abi.decode(_signature, (bytes32, bytes32, uint8)); + address signer = ecrecover( + keccak256(abi.encodePacked('\x19Ethereum Signed Message:\n32', _hash)), + v, + r, + s + ); + require(signer != address(0), 'Invalid recovery'); + return signer == OWNER ? MAGIC_VALUE : bytes4(0xFFFFFFFF); + } +} diff --git a/contracts/mocks/MockFollowModule.sol b/contracts/mocks/MockFollowModule.sol index 466bb13..58ce4c8 100644 --- a/contracts/mocks/MockFollowModule.sol +++ b/contracts/mocks/MockFollowModule.sol @@ -1,39 +1,28 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IFollowModule} from '../interfaces/IFollowModule.sol'; +/** + * @dev This is a simple mock follow module to be used for testing. + */ contract MockFollowModule is IFollowModule { - function initializeFollowModule(uint256 profileId, bytes calldata data) - external - pure - override - returns (bytes memory) - { + function initializeFollowModule( + uint256 profileId, + address executor, + bytes calldata data + ) external pure override returns (bytes memory) { uint256 number = abi.decode(data, (uint256)); require(number == 1, 'MockFollowModule: invalid'); return new bytes(0); } function processFollow( - address follower, + uint256 followerProfileId, + uint256 followTokenId, + address executor, uint256 profileId, bytes calldata data - ) external override {} - - function isFollowing( - uint256 profileId, - address follower, - uint256 followNFTTokenId - ) external view override returns (bool) { - return true; - } - - function followModuleTransferHook( - uint256 profileId, - address from, - address to, - uint256 followNFTTokenId - ) external override {} + ) external pure override {} } diff --git a/contracts/mocks/MockFollowModuleWithRevertFlag.sol b/contracts/mocks/MockFollowModuleWithRevertFlag.sol new file mode 100644 index 0000000..e14c970 --- /dev/null +++ b/contracts/mocks/MockFollowModuleWithRevertFlag.sol @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.15; + +import {IFollowModule} from '../interfaces/IFollowModule.sol'; + +/** + * @dev This is a simple mock follow module to be used for testing revert cases on processFollow. + */ +contract MockFollowModuleWithRevertFlag is IFollowModule { + error MockFollowModuleReverted(); + + function initializeFollowModule( + uint256 profileId, + address executor, + bytes calldata data + ) external pure override returns (bytes memory) { + return new bytes(0); + } + + function processFollow( + uint256 followerProfileId, + uint256 followTokenId, + address executor, + uint256 profileId, + bytes calldata data + ) external pure override { + if (abi.decode(data, (bool))) { + revert MockFollowModuleReverted(); + } + } +} diff --git a/contracts/mocks/MockLensHubV2.sol b/contracts/mocks/MockLensHubV2.sol index 7ba7a3e..0bb69c1 100644 --- a/contracts/mocks/MockLensHubV2.sol +++ b/contracts/mocks/MockLensHubV2.sol @@ -1,14 +1,7 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {ILensHub} from '../interfaces/ILensHub.sol'; -import {Events} from '../libraries/Events.sol'; -import {Helpers} from '../libraries/Helpers.sol'; -import {DataTypes} from '../libraries/DataTypes.sol'; -import {Errors} from '../libraries/Errors.sol'; -import {PublishingLogic} from '../libraries/PublishingLogic.sol'; -import {InteractionLogic} from '../libraries/InteractionLogic.sol'; import {LensNFTBase} from '../core/base/LensNFTBase.sol'; import {LensMultiState} from '../core/base/LensMultiState.sol'; import {VersionedInitializable} from '../upgradeability/VersionedInitializable.sol'; diff --git a/contracts/mocks/MockLensHubV2BadRevision.sol b/contracts/mocks/MockLensHubV2BadRevision.sol index a997464..85c626a 100644 --- a/contracts/mocks/MockLensHubV2BadRevision.sol +++ b/contracts/mocks/MockLensHubV2BadRevision.sol @@ -1,14 +1,7 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; -import {ILensHub} from '../interfaces/ILensHub.sol'; -import {Events} from '../libraries/Events.sol'; -import {Helpers} from '../libraries/Helpers.sol'; -import {DataTypes} from '../libraries/DataTypes.sol'; -import {Errors} from '../libraries/Errors.sol'; -import {PublishingLogic} from '../libraries/PublishingLogic.sol'; -import {InteractionLogic} from '../libraries/InteractionLogic.sol'; import {LensNFTBase} from '../core/base/LensNFTBase.sol'; import {LensMultiState} from '../core/base/LensMultiState.sol'; import {VersionedInitializable} from '../upgradeability/VersionedInitializable.sol'; diff --git a/contracts/mocks/MockLensHubV2Storage.sol b/contracts/mocks/MockLensHubV2Storage.sol index c7371b7..4ad0e25 100644 --- a/contracts/mocks/MockLensHubV2Storage.sol +++ b/contracts/mocks/MockLensHubV2Storage.sol @@ -1,68 +1,12 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {DataTypes} from '../libraries/DataTypes.sol'; +import {LensHubStorage} from '../core/storage/LensHubStorage.sol'; -contract MockLensHubV2Storage { - bytes32 internal constant CREATE_PROFILE_WITH_SIG_TYPEHASH = - 0x9ac3269d9abd6f8c5e850e07f21b199079e8a5cc4a55466d8c96ab0c4a5be403; - // keccak256( - // 'CreateProfileWithSig(string handle,string uri,address followModule,bytes followModuleData,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH = - 0x6f3f6455a608af1cc57ef3e5c0a49deeb88bba264ec8865b798ff07358859d4b; - // keccak256( - // 'SetFollowModuleWithSig(uint256 profileId,address followModule,bytes followModuleData,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant SET_DISPATCHER_WITH_SIG_TYPEHASH = - 0x77ba3e9f5fa75343bbad1241fb539a0064de97694b47d463d1eb5c54aba11f0f; - // keccak256( - // 'SetDispatcherWithSig(uint256 profileId,address dispatcher,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH = - 0x5b9860bd835e648945b22d053515bc1f53b7d9fab4b23b1b49db15722e945d14; - // keccak256( - // 'SetProfileImageURIWithSig(uint256 profileId,string imageURI,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant POST_WITH_SIG_TYPEHASH = - 0xfb8f057542e7551386ead0b891a45f102af78c47f8cc58b4a919c7cfeccd0e1e; - // keccak256( - // 'PostWithSig(uint256 profileId,string contentURI,address collectModule,bytes collectModuleData,address referenceModule,bytes referenceModuleData,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant COMMENT_WITH_SIG_TYPEHASH = - 0xb30910150df56294e05b2d03e181803697a2b935abb1b9bdddde9310f618fe9b; - // keccak256( - // 'CommentWithSig(uint256 profileId,string contentURI,uint256 profileIdPointed,uint256 pubIdPointed,address collectModule,bytes collectModuleData,address referenceModule,bytes referenceModuleData,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant MIRROR_WITH_SIG_TYPEHASH = - 0x64f4578fc098f96a2450fbe601cb8c5318ebeb2ff72d2031a36be1ff6932d5ee; - // keccak256( - // 'MirrorWithSig(uint256 profileId,uint256 profileIdPointed,uint256 pubIdPointed,address referenceModule,bytes referenceModuleData,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant FOLLOW_WITH_SIG_TYPEHASH = - 0xfb6b7f1cd1b38daf3822aff0abbe78124db5d62a4748bcff007c15ccd6d30bc5; - // keccak256( - // 'FollowWithSig(uint256[] profileIds,bytes[] datas,uint256 nonce,uint256 deadline)' - // ); - bytes32 internal constant COLLECT_WITH_SIG_TYPEHASH = - 0x7f9b4ea1fc678b4fda1611ac5cbd28f339e235d89b1540635e9b2e0223a3c101; - // keccak256( - // 'CollectWithSig(uint256 profileId,uint256 pubId,bytes data,uint256 nonce,uint256 deadline)' - // ); - - mapping(address => bool) internal _followModuleWhitelisted; - mapping(address => bool) internal _collectModuleWhitelisted; - mapping(address => bool) internal _referenceModuleWhitelisted; - - mapping(uint256 => address) internal _dispatcherByProfile; - mapping(bytes32 => uint256) internal _profileIdByHandleHash; - mapping(uint256 => DataTypes.ProfileStruct) internal _profileById; - mapping(uint256 => mapping(uint256 => DataTypes.PublicationStruct)) internal _pubByIdByProfile; - - mapping(address => uint256) internal _defaultProfileByAddress; - - uint256 internal _profileCounter; - address internal _governance; - address internal _emergencyAdmin; +/** + * @dev This is a simple mock LensHub storage contract to be used for testing. + */ +contract MockLensHubV2Storage is LensHubStorage { uint256 internal _additionalValue; } diff --git a/contracts/mocks/MockProfileCreationProxy.sol b/contracts/mocks/MockProfileCreationProxy.sol index 3026d50..ae7994c 100644 --- a/contracts/mocks/MockProfileCreationProxy.sol +++ b/contracts/mocks/MockProfileCreationProxy.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ILensHub} from '../interfaces/ILensHub.sol'; import {DataTypes} from '../libraries/DataTypes.sol'; @@ -20,21 +20,6 @@ contract MockProfileCreationProxy { } function proxyCreateProfile(DataTypes.CreateProfileData memory vars) external { - uint256 handleLength = bytes(vars.handle).length; - if (handleLength < 5) revert Errors.HandleLengthInvalid(); - - bytes1 firstByte = bytes(vars.handle)[0]; - if (firstByte == '-' || firstByte == '_' || firstByte == '.') - revert Errors.HandleFirstCharInvalid(); - - for (uint256 i = 1; i < handleLength; ) { - if (bytes(vars.handle)[i] == '.') revert Errors.HandleContainsInvalidCharacters(); - unchecked { - ++i; - } - } - - vars.handle = string(abi.encodePacked(vars.handle, '.test')); LENS_HUB.createProfile(vars); } } diff --git a/contracts/mocks/MockReferenceModule.sol b/contracts/mocks/MockReferenceModule.sol index 50ccf88..4464ea6 100644 --- a/contracts/mocks/MockReferenceModule.sol +++ b/contracts/mocks/MockReferenceModule.sol @@ -1,13 +1,17 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {IReferenceModule} from '../interfaces/IReferenceModule.sol'; +/** + * @dev This is a simple mock follow module to be used for testing. + */ contract MockReferenceModule is IReferenceModule { function initializeReferenceModule( - uint256 profileId, - uint256 pubId, + uint256, + address, + uint256, bytes calldata data ) external pure override returns (bytes memory) { uint256 number = abi.decode(data, (uint256)); @@ -17,6 +21,7 @@ contract MockReferenceModule is IReferenceModule { function processComment( uint256 profileId, + address executor, uint256 profileIdPointed, uint256 pubIdPointed, bytes calldata data @@ -24,6 +29,7 @@ contract MockReferenceModule is IReferenceModule { function processMirror( uint256 profileId, + address executor, uint256 profileIdPointed, uint256 pubIdPointed, bytes calldata data diff --git a/contracts/upgradeability/FollowNFTProxy.sol b/contracts/upgradeability/FollowNFTProxy.sol index f123fdb..0df78d9 100644 --- a/contracts/upgradeability/FollowNFTProxy.sol +++ b/contracts/upgradeability/FollowNFTProxy.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {ILensHub} from '../interfaces/ILensHub.sol'; import {Proxy} from '@openzeppelin/contracts/proxy/Proxy.sol'; diff --git a/contracts/upgradeability/TransparentUpgradeableProxy.sol b/contracts/upgradeability/TransparentUpgradeableProxy.sol index b7aca36..d869a00 100644 --- a/contracts/upgradeability/TransparentUpgradeableProxy.sol +++ b/contracts/upgradeability/TransparentUpgradeableProxy.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8.0; -import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; +import '@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol'; /** * NOTE: This is a direct copy of OpenZeppelin's TransparentUpgradeableProxy and is only present for @@ -39,7 +39,7 @@ contract TransparentUpgradeableProxy is ERC1967Proxy { address admin_, bytes memory _data ) payable ERC1967Proxy(_logic, _data) { - assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1)); + assert(_ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _changeAdmin(admin_); } @@ -97,7 +97,7 @@ contract TransparentUpgradeableProxy is ERC1967Proxy { * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}. */ function upgradeTo(address newImplementation) external ifAdmin { - _upgradeToAndCall(newImplementation, bytes(""), false); + _upgradeToAndCall(newImplementation, bytes(''), false); } /** @@ -107,7 +107,11 @@ contract TransparentUpgradeableProxy is ERC1967Proxy { * * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}. */ - function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin { + function upgradeToAndCall(address newImplementation, bytes calldata data) + external + payable + ifAdmin + { _upgradeToAndCall(newImplementation, data, true); } @@ -122,7 +126,10 @@ contract TransparentUpgradeableProxy is ERC1967Proxy { * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}. */ function _beforeFallback() internal virtual override { - require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target"); + require( + msg.sender != _getAdmin(), + 'TransparentUpgradeableProxy: admin cannot fallback to proxy target' + ); super._beforeFallback(); } } diff --git a/contracts/upgradeability/VersionedInitializable.sol b/contracts/upgradeability/VersionedInitializable.sol index 320fdc9..03632e2 100644 --- a/contracts/upgradeability/VersionedInitializable.sol +++ b/contracts/upgradeability/VersionedInitializable.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -pragma solidity 0.8.10; +pragma solidity 0.8.15; import {Errors} from '../libraries/Errors.sol'; diff --git a/docker-compose.yml b/docker-compose.yml deleted file mode 100644 index 2e5a374..0000000 --- a/docker-compose.yml +++ /dev/null @@ -1,22 +0,0 @@ -version: '3.5' - -services: - contracts-env: - user: "${USERID?}:${USERID?}" - env_file: - - .env - build: - context: ./ - stdin_open: true - tty: true - volumes: - - ./:/src:rw - - $HOME/.tenderly/config.yaml:/root/.tenderly/config.yaml:ro - #environment: - #- MNEMONIC= - #- RPC_URL= - #- BLOCK_EXPLORER_KEY= - #- TENDERLY_PROJECT= - #- TENDERLY_USERNAME= - #- TENDERLY_FORK_ID= - #- TENDERLY_HEAD_ID= diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh deleted file mode 100644 index 4a1d5f6..0000000 --- a/docker-entrypoint.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/bash - -[ ! -d "/src/node_modules" ] && cp /node_modules /src/node_modules; bash diff --git a/foundry-scripts/DeployUpgrade.s.sol b/foundry-scripts/DeployUpgrade.s.sol new file mode 100644 index 0000000..34fb2c8 --- /dev/null +++ b/foundry-scripts/DeployUpgrade.s.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import 'forge-std/Script.sol'; +import 'forge-std/console2.sol'; + +import '../contracts/core/LensHub.sol'; +import '../contracts/core/FollowNFT.sol'; +import '../contracts/core/CollectNFT.sol'; + +/** + * This script will deploy the current repository implementations, using the given environment + * hub proxy address. + */ +contract DeployUpgradeScript is Script { + function run() public { + uint256 deployerKey = vm.envUint('DEPLOYER_KEY'); + address deployer = vm.addr(deployerKey); + address hubProxyAddr = vm.envAddress('HUB_PROXY_ADDRESS'); + + // Start deployments. + vm.startBroadcast(deployerKey); + + // Precompute needed addresss. + address followNFTAddr = computeCreateAddress(deployer, 1); + address collectNFTAddr = computeCreateAddress(deployer, 2); + + // Deploy implementation contracts. + address hubImpl = address(new LensHub(followNFTAddr, collectNFTAddr)); + address followNFT = address(new FollowNFT(hubProxyAddr)); + address collectNFT = address(new CollectNFT(hubProxyAddr)); + + vm.writeFile("addrs", ""); + vm.writeLine("addrs", string(abi.encodePacked("hubImpl: ", vm.toString(hubImpl)))); + vm.writeLine("addrs", string(abi.encodePacked("followNFT: ", vm.toString(followNFT)))); + vm.writeLine("addrs", string(abi.encodePacked("collectNFT: ", vm.toString(collectNFT)))); + } +} diff --git a/foundry.toml b/foundry.toml new file mode 100644 index 0000000..72595c3 --- /dev/null +++ b/foundry.toml @@ -0,0 +1,13 @@ +[profile.default] +src = 'contracts' +out = 'out' +libs = ['node_modules', 'lib'] +test = 'test/foundry' +cache_path = 'forge-cache' +fs_permissions = [{ access = "read-write", path = "./"}] + +[rpc_endpoints] +polygon = "${POLYGON_RPC_URL}" + +[fuzz] +runs = 10000 diff --git a/hardhat.config.ts b/hardhat.config.ts index d68988c..310678a 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -16,6 +16,7 @@ import 'hardhat-gas-reporter'; import 'hardhat-contract-sizer'; import 'hardhat-log-remover'; import 'hardhat-spdx-license-identifier'; +import 'hardhat-tracer'; if (!process.env.SKIP_LOAD) { glob.sync('./tasks/**/*.ts').forEach(function (file) { @@ -23,7 +24,6 @@ if (!process.env.SKIP_LOAD) { }); } -const DEFAULT_BLOCK_GAS_LIMIT = 12450000; const MNEMONIC_PATH = "m/44'/60'/0'/0"; const MNEMONIC = process.env.MNEMONIC || ''; const MAINNET_FORK = process.env.MAINNET_FORK === 'true'; @@ -48,10 +48,13 @@ const mainnetFork = MAINNET_FORK : undefined; const config: HardhatUserConfig = { + tracer: { + enabled: false, + }, solidity: { compilers: [ { - version: '0.8.10', + version: '0.8.15', settings: { optimizer: { enabled: true, @@ -73,11 +76,6 @@ const config: HardhatUserConfig = { mumbai: getCommonNetworkConfig(ePolygonNetwork.mumbai, 80001), xdai: getCommonNetworkConfig(eXDaiNetwork.xdai, 100), hardhat: { - hardfork: 'london', - blockGasLimit: DEFAULT_BLOCK_GAS_LIMIT, - gas: DEFAULT_BLOCK_GAS_LIMIT, - gasPrice: 8000000000, - chainId: HARDHATEVM_CHAINID, throwOnTransactionFailures: true, throwOnCallFailures: true, accounts: accounts.map(({ secretKey, balance }: { secretKey: string; balance: string }) => ({ @@ -85,6 +83,7 @@ const config: HardhatUserConfig = { balance, })), forking: mainnetFork, + allowUnlimitedContractSize: true, }, }, gasReporter: { diff --git a/lib/forge-std/.github/workflows/tests.yml b/lib/forge-std/.github/workflows/tests.yml new file mode 100644 index 0000000..8e86b25 --- /dev/null +++ b/lib/forge-std/.github/workflows/tests.yml @@ -0,0 +1,27 @@ +name: Tests +on: [push, pull_request] + +jobs: + check: + name: Foundry project + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + submodules: recursive + + - name: Install Foundry + uses: onbjerg/foundry-toolchain@v1 + with: + version: nightly + + - name: Install dependencies + run: forge install + - name: Run tests + run: forge test -vvv + - name: Build Test with older solc versions + run: | + forge build --contracts src/Test.sol --use solc:0.8.0 + forge build --contracts src/Test.sol --use solc:0.7.6 + forge build --contracts src/Test.sol --use solc:0.7.0 + forge build --contracts src/Test.sol --use solc:0.6.0 diff --git a/lib/forge-std/.gitignore b/lib/forge-std/.gitignore new file mode 100644 index 0000000..999e4a7 --- /dev/null +++ b/lib/forge-std/.gitignore @@ -0,0 +1,4 @@ +cache/ +out/ +.vscode +.idea \ No newline at end of file diff --git a/lib/forge-std/.gitmodules b/lib/forge-std/.gitmodules new file mode 100644 index 0000000..e124719 --- /dev/null +++ b/lib/forge-std/.gitmodules @@ -0,0 +1,3 @@ +[submodule "lib/ds-test"] + path = lib/ds-test + url = https://github.com/dapphub/ds-test diff --git a/lib/forge-std/LICENSE-APACHE b/lib/forge-std/LICENSE-APACHE new file mode 100644 index 0000000..28d22de --- /dev/null +++ b/lib/forge-std/LICENSE-APACHE @@ -0,0 +1,203 @@ +Copyright Contributors to forge-std + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/lib/forge-std/LICENSE-MIT b/lib/forge-std/LICENSE-MIT new file mode 100644 index 0000000..1538ed3 --- /dev/null +++ b/lib/forge-std/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright Contributors to forge-std + +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 O THE USE OR OTHER +DEALINGS IN THE SOFTWARE.R diff --git a/lib/forge-std/README.md b/lib/forge-std/README.md new file mode 100644 index 0000000..67dc160 --- /dev/null +++ b/lib/forge-std/README.md @@ -0,0 +1,246 @@ +# Forge Standard Library • [![tests](https://github.com/brockelmore/forge-std/actions/workflows/tests.yml/badge.svg)](https://github.com/brockelmore/forge-std/actions/workflows/tests.yml) + +Forge Standard Library is a collection of helpful contracts for use with [`forge` and `foundry`](https://github.com/foundry-rs/foundry). It leverages `forge`'s cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes. + +**Learn how to use Forge Std with the [📖 Foundry Book (Forge Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).** + +## Install + +```bash +forge install foundry-rs/forge-std +``` + +## Contracts +### stdError + +This is a helper contract for errors and reverts. In `forge`, this contract is particularly helpful for the `expectRevert` cheatcode, as it provides all compiler builtin errors. + +See the contract itself for all error codes. + +#### Example usage + +```solidity + +import "forge-std/Test.sol"; + +contract TestContract is Test { + ErrorsTest test; + + function setUp() public { + test = new ErrorsTest(); + } + + function testExpectArithmetic() public { + vm.expectRevert(stdError.arithmeticError); + test.arithmeticError(10); + } +} + +contract ErrorsTest { + function arithmeticError(uint256 a) public { + uint256 a = a - 100; + } +} +``` + +### stdStorage + +This is a rather large contract due to all of the overloading to make the UX decent. Primarily, it is a wrapper around the `record` and `accesses` cheatcodes. It can *always* find and write the storage slot(s) associated with a particular variable without knowing the storage layout. The one _major_ caveat to this is while a slot can be found for packed storage variables, we can't write to that variable safely. If a user tries to write to a packed slot, the execution throws an error, unless it is uninitialized (`bytes32(0)`). + +This works by recording all `SLOAD`s and `SSTORE`s during a function call. If there is a single slot read or written to, it immediately returns the slot. Otherwise, behind the scenes, we iterate through and check each one (assuming the user passed in a `depth` parameter). If the variable is a struct, you can pass in a `depth` parameter which is basically the field depth. + +I.e.: +```solidity +struct T { + // depth 0 + uint256 a; + // depth 1 + uint256 b; +} +``` + +#### Example usage + +```solidity +import "forge-std/Test.sol"; + +contract TestContract is Test { + using stdStorage for StdStorage; + + Storage test; + + function setUp() public { + test = new Storage(); + } + + function testFindExists() public { + // Lets say we want to find the slot for the public + // variable `exists`. We just pass in the function selector + // to the `find` command + uint256 slot = stdstore.target(address(test)).sig("exists()").find(); + assertEq(slot, 0); + } + + function testWriteExists() public { + // Lets say we want to write to the slot for the public + // variable `exists`. We just pass in the function selector + // to the `checked_write` command + stdstore.target(address(test)).sig("exists()").checked_write(100); + assertEq(test.exists(), 100); + } + + // It supports arbitrary storage layouts, like assembly based storage locations + function testFindHidden() public { + // `hidden` is a random hash of a bytes, iteration through slots would + // not find it. Our mechanism does + // Also, you can use the selector instead of a string + uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find(); + assertEq(slot, uint256(keccak256("my.random.var"))); + } + + // If targeting a mapping, you have to pass in the keys necessary to perform the find + // i.e.: + function testFindMapping() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.map_addr.selector) + .with_key(address(this)) + .find(); + // in the `Storage` constructor, we wrote that this address' value was 1 in the map + // so when we load the slot, we expect it to be 1 + assertEq(uint(vm.load(address(test), bytes32(slot))), 1); + } + + // If the target is a struct, you can specify the field depth: + function testFindStruct() public { + // NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc. + uint256 slot_for_a_field = stdstore + .target(address(test)) + .sig(test.basicStruct.selector) + .depth(0) + .find(); + + uint256 slot_for_b_field = stdstore + .target(address(test)) + .sig(test.basicStruct.selector) + .depth(1) + .find(); + + assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1); + assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2); + } +} + +// A complex storage contract +contract Storage { + struct UnpackedStruct { + uint256 a; + uint256 b; + } + + constructor() { + map_addr[msg.sender] = 1; + } + + uint256 public exists = 1; + mapping(address => uint256) public map_addr; + // mapping(address => Packed) public map_packed; + mapping(address => UnpackedStruct) public map_struct; + mapping(address => mapping(address => uint256)) public deep_map; + mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct; + UnpackedStruct public basicStruct = UnpackedStruct({ + a: 1, + b: 2 + }); + + function hidden() public view returns (bytes32 t) { + // an extremely hidden storage slot + bytes32 slot = keccak256("my.random.var"); + assembly { + t := sload(slot) + } + } +} +``` + +### stdCheats + +This is a wrapper over miscellaneous cheatcodes that need wrappers to be more dev friendly. Currently there are only functions related to `prank`. In general, users may expect ETH to be put into an address on `prank`, but this is not the case for safety reasons. Explicitly this `hoax` function should only be used for address that have expected balances as it will get overwritten. If an address already has ETH, you should just use `prank`. If you want to change that balance explicitly, just use `deal`. If you want to do both, `hoax` is also right for you. + + +#### Example usage: +```solidity + +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import "forge-std/Test.sol"; + +// Inherit the stdCheats +contract StdCheatsTest is Test { + Bar test; + function setUp() public { + test = new Bar(); + } + + function testHoax() public { + // we call `hoax`, which gives the target address + // eth and then calls `prank` + hoax(address(1337)); + test.bar{value: 100}(address(1337)); + + // overloaded to allow you to specify how much eth to + // initialize the address with + hoax(address(1337), 1); + test.bar{value: 1}(address(1337)); + } + + function testStartHoax() public { + // we call `startHoax`, which gives the target address + // eth and then calls `startPrank` + // + // it is also overloaded so that you can specify an eth amount + startHoax(address(1337)); + test.bar{value: 100}(address(1337)); + test.bar{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } +} + +contract Bar { + function bar(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + } +} +``` + +### Std Assertions + +Expand upon the assertion functions from the `DSTest` library. + +### `console.log` + +Usage follows the same format as [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log). +It's recommended to use `console2.sol` as shown below, as this will show the decoded logs in Forge traces. + +```solidity +// import it indirectly via Test.sol +import "forge-std/Test.sol"; +// or directly import it +import "forge-std/console2.sol"; +... +console2.log(someValue); +``` + +If you need compatibility with Hardhat, you must use the standard `console.sol` instead. +Due to a bug in `console.sol`, logs that use `uint256` or `int256` types will not be properly decoded in Forge traces. + +```solidity +// import it indirectly via Test.sol +import "forge-std/Test.sol"; +// or directly import it +import "forge-std/console.sol"; +... +console.log(someValue); +``` diff --git a/lib/forge-std/foundry.toml b/lib/forge-std/foundry.toml new file mode 100644 index 0000000..507b8bb --- /dev/null +++ b/lib/forge-std/foundry.toml @@ -0,0 +1,2 @@ +[profile.default] +fs_permissions = [{ access = "read-write", path = "./"}] diff --git a/lib/forge-std/lib/ds-test/.gitignore b/lib/forge-std/lib/ds-test/.gitignore new file mode 100644 index 0000000..63f0b2c --- /dev/null +++ b/lib/forge-std/lib/ds-test/.gitignore @@ -0,0 +1,3 @@ +/.dapple +/build +/out diff --git a/lib/forge-std/lib/ds-test/LICENSE b/lib/forge-std/lib/ds-test/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/lib/forge-std/lib/ds-test/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/lib/forge-std/lib/ds-test/Makefile b/lib/forge-std/lib/ds-test/Makefile new file mode 100644 index 0000000..661dac4 --- /dev/null +++ b/lib/forge-std/lib/ds-test/Makefile @@ -0,0 +1,14 @@ +all:; dapp build + +test: + -dapp --use solc:0.4.23 build + -dapp --use solc:0.4.26 build + -dapp --use solc:0.5.17 build + -dapp --use solc:0.6.12 build + -dapp --use solc:0.7.5 build + +demo: + DAPP_SRC=demo dapp --use solc:0.7.5 build + -hevm dapp-test --verbose 3 + +.PHONY: test demo diff --git a/lib/forge-std/lib/ds-test/default.nix b/lib/forge-std/lib/ds-test/default.nix new file mode 100644 index 0000000..cf65419 --- /dev/null +++ b/lib/forge-std/lib/ds-test/default.nix @@ -0,0 +1,4 @@ +{ solidityPackage, dappsys }: solidityPackage { + name = "ds-test"; + src = ./src; +} diff --git a/lib/forge-std/lib/ds-test/demo/demo.sol b/lib/forge-std/lib/ds-test/demo/demo.sol new file mode 100644 index 0000000..f3bb48e --- /dev/null +++ b/lib/forge-std/lib/ds-test/demo/demo.sol @@ -0,0 +1,222 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +pragma solidity >=0.5.0; + +import "../src/test.sol"; + +contract DemoTest is DSTest { + function test_this() public pure { + require(true); + } + function test_logs() public { + emit log("-- log(string)"); + emit log("a string"); + + emit log("-- log_named_uint(string, uint)"); + emit log_named_uint("uint", 512); + + emit log("-- log_named_int(string, int)"); + emit log_named_int("int", -512); + + emit log("-- log_named_address(string, address)"); + emit log_named_address("address", address(this)); + + emit log("-- log_named_bytes32(string, bytes32)"); + emit log_named_bytes32("bytes32", "a string"); + + emit log("-- log_named_bytes(string, bytes)"); + emit log_named_bytes("bytes", hex"cafefe"); + + emit log("-- log_named_string(string, string)"); + emit log_named_string("string", "a string"); + + emit log("-- log_named_decimal_uint(string, uint, uint)"); + emit log_named_decimal_uint("decimal uint", 1.0e18, 18); + + emit log("-- log_named_decimal_int(string, int, uint)"); + emit log_named_decimal_int("decimal int", -1.0e18, 18); + } + event log_old_named_uint(bytes32,uint); + function test_old_logs() public { + emit log_old_named_uint("key", 500); + emit log_named_bytes32("bkey", "val"); + } + function test_trace() public view { + this.echo("string 1", "string 2"); + } + function test_multiline() public { + emit log("a multiline\\nstring"); + emit log("a multiline string"); + emit log_bytes("a string"); + emit log_bytes("a multiline\nstring"); + emit log_bytes("a multiline\\nstring"); + emit logs(hex"0000"); + emit log_named_bytes("0x0000", hex"0000"); + emit logs(hex"ff"); + } + function echo(string memory s1, string memory s2) public pure + returns (string memory, string memory) + { + return (s1, s2); + } + + function prove_this(uint x) public { + emit log_named_uint("sym x", x); + assertGt(x + 1, 0); + } + + function test_logn() public { + assembly { + log0(0x01, 0x02) + log1(0x01, 0x02, 0x03) + log2(0x01, 0x02, 0x03, 0x04) + log3(0x01, 0x02, 0x03, 0x04, 0x05) + } + } + + event MyEvent(uint, uint indexed, uint, uint indexed); + function test_events() public { + emit MyEvent(1, 2, 3, 4); + } + + function test_asserts() public { + string memory err = "this test has failed!"; + emit log("## assertTrue(bool)\n"); + assertTrue(false); + emit log("\n"); + assertTrue(false, err); + + emit log("\n## assertEq(address,address)\n"); + assertEq(address(this), msg.sender); + emit log("\n"); + assertEq(address(this), msg.sender, err); + + emit log("\n## assertEq32(bytes32,bytes32)\n"); + assertEq32("bytes 1", "bytes 2"); + emit log("\n"); + assertEq32("bytes 1", "bytes 2", err); + + emit log("\n## assertEq(bytes32,bytes32)\n"); + assertEq32("bytes 1", "bytes 2"); + emit log("\n"); + assertEq32("bytes 1", "bytes 2", err); + + emit log("\n## assertEq(uint,uint)\n"); + assertEq(uint(0), 1); + emit log("\n"); + assertEq(uint(0), 1, err); + + emit log("\n## assertEq(int,int)\n"); + assertEq(-1, -2); + emit log("\n"); + assertEq(-1, -2, err); + + emit log("\n## assertEqDecimal(int,int,uint)\n"); + assertEqDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertEqDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertEqDecimal(uint,uint,uint)\n"); + assertEqDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertEqDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertGt(uint,uint)\n"); + assertGt(uint(0), 0); + emit log("\n"); + assertGt(uint(0), 0, err); + + emit log("\n## assertGt(int,int)\n"); + assertGt(-1, -1); + emit log("\n"); + assertGt(-1, -1, err); + + emit log("\n## assertGtDecimal(int,int,uint)\n"); + assertGtDecimal(-2.0e18, -1.1e18, 18); + emit log("\n"); + assertGtDecimal(-2.0e18, -1.1e18, 18, err); + + emit log("\n## assertGtDecimal(uint,uint,uint)\n"); + assertGtDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertGtDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertGe(uint,uint)\n"); + assertGe(uint(0), 1); + emit log("\n"); + assertGe(uint(0), 1, err); + + emit log("\n## assertGe(int,int)\n"); + assertGe(-1, 0); + emit log("\n"); + assertGe(-1, 0, err); + + emit log("\n## assertGeDecimal(int,int,uint)\n"); + assertGeDecimal(-2.0e18, -1.1e18, 18); + emit log("\n"); + assertGeDecimal(-2.0e18, -1.1e18, 18, err); + + emit log("\n## assertGeDecimal(uint,uint,uint)\n"); + assertGeDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertGeDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertLt(uint,uint)\n"); + assertLt(uint(0), 0); + emit log("\n"); + assertLt(uint(0), 0, err); + + emit log("\n## assertLt(int,int)\n"); + assertLt(-1, -1); + emit log("\n"); + assertLt(-1, -1, err); + + emit log("\n## assertLtDecimal(int,int,uint)\n"); + assertLtDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertLtDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertLtDecimal(uint,uint,uint)\n"); + assertLtDecimal(uint(2.0e18), 1.1e18, 18); + emit log("\n"); + assertLtDecimal(uint(2.0e18), 1.1e18, 18, err); + + emit log("\n## assertLe(uint,uint)\n"); + assertLe(uint(1), 0); + emit log("\n"); + assertLe(uint(1), 0, err); + + emit log("\n## assertLe(int,int)\n"); + assertLe(0, -1); + emit log("\n"); + assertLe(0, -1, err); + + emit log("\n## assertLeDecimal(int,int,uint)\n"); + assertLeDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertLeDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertLeDecimal(uint,uint,uint)\n"); + assertLeDecimal(uint(2.0e18), 1.1e18, 18); + emit log("\n"); + assertLeDecimal(uint(2.0e18), 1.1e18, 18, err); + + emit log("\n## assertEq(string,string)\n"); + string memory s1 = "string 1"; + string memory s2 = "string 2"; + assertEq(s1, s2); + emit log("\n"); + assertEq(s1, s2, err); + + emit log("\n## assertEq0(bytes,bytes)\n"); + assertEq0(hex"abcdef01", hex"abcdef02"); + emit log("\n"); + assertEq0(hex"abcdef01", hex"abcdef02", err); + } +} + +contract DemoTestWithSetUp { + function setUp() public { + } + function test_pass() public pure { + } +} diff --git a/lib/forge-std/lib/ds-test/src/test.sol b/lib/forge-std/lib/ds-test/src/test.sol new file mode 100644 index 0000000..515a3bd --- /dev/null +++ b/lib/forge-std/lib/ds-test/src/test.sol @@ -0,0 +1,469 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +pragma solidity >=0.5.0; + +contract DSTest { + event log (string); + event logs (bytes); + + event log_address (address); + event log_bytes32 (bytes32); + event log_int (int); + event log_uint (uint); + event log_bytes (bytes); + event log_string (string); + + event log_named_address (string key, address val); + event log_named_bytes32 (string key, bytes32 val); + event log_named_decimal_int (string key, int val, uint decimals); + event log_named_decimal_uint (string key, uint val, uint decimals); + event log_named_int (string key, int val); + event log_named_uint (string key, uint val); + event log_named_bytes (string key, bytes val); + event log_named_string (string key, string val); + + bool public IS_TEST = true; + bool private _failed; + + address constant HEVM_ADDRESS = + address(bytes20(uint160(uint256(keccak256('hevm cheat code'))))); + + modifier mayRevert() { _; } + modifier testopts(string memory) { _; } + + function failed() public returns (bool) { + if (_failed) { + return _failed; + } else { + bool globalFailed = false; + if (hasHEVMContext()) { + (, bytes memory retdata) = HEVM_ADDRESS.call( + abi.encodePacked( + bytes4(keccak256("load(address,bytes32)")), + abi.encode(HEVM_ADDRESS, bytes32("failed")) + ) + ); + globalFailed = abi.decode(retdata, (bool)); + } + return globalFailed; + } + } + + function fail() internal { + if (hasHEVMContext()) { + (bool status, ) = HEVM_ADDRESS.call( + abi.encodePacked( + bytes4(keccak256("store(address,bytes32,bytes32)")), + abi.encode(HEVM_ADDRESS, bytes32("failed"), bytes32(uint256(0x01))) + ) + ); + status; // Silence compiler warnings + } + _failed = true; + } + + function hasHEVMContext() internal view returns (bool) { + uint256 hevmCodeSize = 0; + assembly { + hevmCodeSize := extcodesize(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D) + } + return hevmCodeSize > 0; + } + + modifier logs_gas() { + uint startGas = gasleft(); + _; + uint endGas = gasleft(); + emit log_named_uint("gas", startGas - endGas); + } + + function assertTrue(bool condition) internal { + if (!condition) { + emit log("Error: Assertion Failed"); + fail(); + } + } + + function assertTrue(bool condition, string memory err) internal { + if (!condition) { + emit log_named_string("Error", err); + assertTrue(condition); + } + } + + function assertEq(address a, address b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [address]"); + emit log_named_address(" Expected", b); + emit log_named_address(" Actual", a); + fail(); + } + } + function assertEq(address a, address b, string memory err) internal { + if (a != b) { + emit log_named_string ("Error", err); + assertEq(a, b); + } + } + + function assertEq(bytes32 a, bytes32 b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [bytes32]"); + emit log_named_bytes32(" Expected", b); + emit log_named_bytes32(" Actual", a); + fail(); + } + } + function assertEq(bytes32 a, bytes32 b, string memory err) internal { + if (a != b) { + emit log_named_string ("Error", err); + assertEq(a, b); + } + } + function assertEq32(bytes32 a, bytes32 b) internal { + assertEq(a, b); + } + function assertEq32(bytes32 a, bytes32 b, string memory err) internal { + assertEq(a, b, err); + } + + function assertEq(int a, int b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [int]"); + emit log_named_int(" Expected", b); + emit log_named_int(" Actual", a); + fail(); + } + } + function assertEq(int a, int b, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + function assertEq(uint a, uint b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [uint]"); + emit log_named_uint(" Expected", b); + emit log_named_uint(" Actual", a); + fail(); + } + } + function assertEq(uint a, uint b, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + function assertEqDecimal(int a, int b, uint decimals) internal { + if (a != b) { + emit log("Error: a == b not satisfied [decimal int]"); + emit log_named_decimal_int(" Expected", b, decimals); + emit log_named_decimal_int(" Actual", a, decimals); + fail(); + } + } + function assertEqDecimal(int a, int b, uint decimals, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEqDecimal(a, b, decimals); + } + } + function assertEqDecimal(uint a, uint b, uint decimals) internal { + if (a != b) { + emit log("Error: a == b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Expected", b, decimals); + emit log_named_decimal_uint(" Actual", a, decimals); + fail(); + } + } + function assertEqDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEqDecimal(a, b, decimals); + } + } + + function assertGt(uint a, uint b) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertGt(uint a, uint b, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGt(a, b); + } + } + function assertGt(int a, int b) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertGt(int a, int b, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGt(a, b); + } + } + function assertGtDecimal(int a, int b, uint decimals) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertGtDecimal(int a, int b, uint decimals, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGtDecimal(a, b, decimals); + } + } + function assertGtDecimal(uint a, uint b, uint decimals) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertGtDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGtDecimal(a, b, decimals); + } + } + + function assertGe(uint a, uint b) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertGe(uint a, uint b, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGe(a, b); + } + } + function assertGe(int a, int b) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertGe(int a, int b, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGe(a, b); + } + } + function assertGeDecimal(int a, int b, uint decimals) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertGeDecimal(int a, int b, uint decimals, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGeDecimal(a, b, decimals); + } + } + function assertGeDecimal(uint a, uint b, uint decimals) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertGeDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGeDecimal(a, b, decimals); + } + } + + function assertLt(uint a, uint b) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertLt(uint a, uint b, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLt(a, b); + } + } + function assertLt(int a, int b) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertLt(int a, int b, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLt(a, b); + } + } + function assertLtDecimal(int a, int b, uint decimals) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertLtDecimal(int a, int b, uint decimals, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLtDecimal(a, b, decimals); + } + } + function assertLtDecimal(uint a, uint b, uint decimals) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertLtDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLtDecimal(a, b, decimals); + } + } + + function assertLe(uint a, uint b) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertLe(uint a, uint b, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLe(a, b); + } + } + function assertLe(int a, int b) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertLe(int a, int b, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLe(a, b); + } + } + function assertLeDecimal(int a, int b, uint decimals) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertLeDecimal(int a, int b, uint decimals, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLeDecimal(a, b, decimals); + } + } + function assertLeDecimal(uint a, uint b, uint decimals) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertLeDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertGeDecimal(a, b, decimals); + } + } + + function assertEq(string memory a, string memory b) internal { + if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { + emit log("Error: a == b not satisfied [string]"); + emit log_named_string(" Expected", b); + emit log_named_string(" Actual", a); + fail(); + } + } + function assertEq(string memory a, string memory b, string memory err) internal { + if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function checkEq0(bytes memory a, bytes memory b) internal pure returns (bool ok) { + ok = true; + if (a.length == b.length) { + for (uint i = 0; i < a.length; i++) { + if (a[i] != b[i]) { + ok = false; + } + } + } else { + ok = false; + } + } + function assertEq0(bytes memory a, bytes memory b) internal { + if (!checkEq0(a, b)) { + emit log("Error: a == b not satisfied [bytes]"); + emit log_named_bytes(" Expected", b); + emit log_named_bytes(" Actual", a); + fail(); + } + } + function assertEq0(bytes memory a, bytes memory b, string memory err) internal { + if (!checkEq0(a, b)) { + emit log_named_string("Error", err); + assertEq0(a, b); + } + } +} diff --git a/lib/forge-std/package.json b/lib/forge-std/package.json new file mode 100644 index 0000000..914a361 --- /dev/null +++ b/lib/forge-std/package.json @@ -0,0 +1,16 @@ +{ + "name": "forge-std", + "version": "0.1.0", + "description": "Forge Standard Library is a collection of helpful contracts for use with forge and foundry", + "homepage": "https://book.getfoundry.sh/forge/forge-std", + "bugs": "https://github.com/foundry-rs/forge-std/issues", + "license": "(Apache-2.0 OR MIT)", + "author": "Contributors to forge-std", + "files": [ + "src/*" + ], + "repository": { + "type": "git", + "url": "https://github.com/foundry-rs/forge-std.git" + } +} diff --git a/lib/forge-std/src/Script.sol b/lib/forge-std/src/Script.sol new file mode 100644 index 0000000..e1e3a51 --- /dev/null +++ b/lib/forge-std/src/Script.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; + +import "./console.sol"; +import "./console2.sol"; +import "./StdJson.sol"; + +abstract contract Script { + bool public IS_SCRIPT = true; + address constant private VM_ADDRESS = + address(bytes20(uint160(uint256(keccak256('hevm cheat code'))))); + + Vm public constant vm = Vm(VM_ADDRESS); + + /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce + /// @notice adapated from Solmate implementation (https://github.com/transmissions11/solmate/blob/main/src/utils/LibRLP.sol) + function computeCreateAddress(address deployer, uint256 nonce) internal pure returns (address) { + // The integer zero is treated as an empty byte string, and as a result it only has a length prefix, 0x80, computed via 0x80 + 0. + // A one byte integer uses its own value as its length prefix, there is no additional "0x80 + length" prefix that comes before it. + if (nonce == 0x00) return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xd6), bytes1(0x94), deployer, bytes1(0x80)))); + if (nonce <= 0x7f) return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xd6), bytes1(0x94), deployer, uint8(nonce)))); + + // Nonces greater than 1 byte all follow a consistent encoding scheme, where each value is preceded by a prefix of 0x80 + length. + if (nonce <= 2**8 - 1) return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xd7), bytes1(0x94), deployer, bytes1(0x81), uint8(nonce)))); + if (nonce <= 2**16 - 1) return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xd8), bytes1(0x94), deployer, bytes1(0x82), uint16(nonce)))); + if (nonce <= 2**24 - 1) return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xd9), bytes1(0x94), deployer, bytes1(0x83), uint24(nonce)))); + + // More details about RLP encoding can be found here: https://eth.wiki/fundamentals/rlp + // 0xda = 0xc0 (short RLP prefix) + 0x16 (length of: 0x94 ++ proxy ++ 0x84 ++ nonce) + // 0x94 = 0x80 + 0x14 (0x14 = the length of an address, 20 bytes, in hex) + // 0x84 = 0x80 + 0x04 (0x04 = the bytes length of the nonce, 4 bytes, in hex) + // We assume nobody can have a nonce large enough to require more than 32 bytes. + return addressFromLast20Bytes(keccak256(abi.encodePacked(bytes1(0xda), bytes1(0x94), deployer, bytes1(0x84), uint32(nonce)))); + } + + function addressFromLast20Bytes(bytes32 bytesValue) internal pure returns (address) { + return address(uint160(uint256(bytesValue))); + } + + function deriveRememberKey(string memory mnemonic, uint32 index) internal returns (address who, uint256 privateKey) { + privateKey = vm.deriveKey(mnemonic, index); + who = vm.rememberKey(privateKey); + } +} diff --git a/lib/forge-std/src/StdJson.sol b/lib/forge-std/src/StdJson.sol new file mode 100644 index 0000000..c4ad825 --- /dev/null +++ b/lib/forge-std/src/StdJson.sol @@ -0,0 +1,118 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; +pragma experimental ABIEncoderV2; + +import "./Vm.sol"; + +// Helpers for parsing keys into types. +library stdJson { + + Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); + + function parseRaw(string memory json, string memory key) + internal + returns (bytes memory) + { + return vm.parseJson(json, key); + } + + function readUint(string memory json, string memory key) + internal + returns (uint256) + { + return abi.decode(vm.parseJson(json, key), (uint256)); + } + + function readUintArray(string memory json, string memory key) + internal + returns (uint256[] memory) + { + return abi.decode(vm.parseJson(json, key), (uint256[])); + } + + function readInt(string memory json, string memory key) + internal + returns (int256) + { + return abi.decode(vm.parseJson(json, key), (int256)); + } + + function readIntArray(string memory json, string memory key) + internal + returns (int256[] memory) + { + return abi.decode(vm.parseJson(json, key), (int256[])); + } + + function readBytes32(string memory json, string memory key) + internal + returns (bytes32) + { + return abi.decode(vm.parseJson(json, key), (bytes32)); + } + + function readBytes32Array(string memory json, string memory key) + internal + returns (bytes32[] memory) + { + return abi.decode(vm.parseJson(json, key), (bytes32[])); + } + + function readString(string memory json, string memory key) + internal + returns (string memory) + { + return abi.decode(vm.parseJson(json, key), (string)); + } + + function readStringArray(string memory json, string memory key) + internal + returns (string[] memory) + { + return abi.decode(vm.parseJson(json, key), (string[])); + } + + function readAddress(string memory json, string memory key) + internal + returns (address) + { + return abi.decode(vm.parseJson(json, key), (address)); + } + + function readAddressArray(string memory json, string memory key) + internal + returns (address[] memory) + { + return abi.decode(vm.parseJson(json, key), (address[])); + } + + function readBool(string memory json, string memory key) + internal + returns (bool) + { + return abi.decode(vm.parseJson(json, key), (bool)); + } + + function readBoolArray(string memory json, string memory key) + internal + returns (bool[] memory) + { + return abi.decode(vm.parseJson(json, key), (bool[])); + } + + function readBytes(string memory json, string memory key) + internal + returns (bytes memory) + { + return abi.decode(vm.parseJson(json, key), (bytes)); + } + + function readBytesArray(string memory json, string memory key) + internal + returns (bytes[] memory) + { + return abi.decode(vm.parseJson(json, key), (bytes[])); + } + + +} diff --git a/lib/forge-std/src/Test.sol b/lib/forge-std/src/Test.sol new file mode 100644 index 0000000..ef18bb6 --- /dev/null +++ b/lib/forge-std/src/Test.sol @@ -0,0 +1,1138 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; +pragma experimental ABIEncoderV2; + +import "./Script.sol"; +import "ds-test/test.sol"; + +// Wrappers around Cheatcodes to avoid footguns +abstract contract Test is DSTest, Script { + using stdStorage for StdStorage; + + uint256 internal constant UINT256_MAX = + 115792089237316195423570985008687907853269984665640564039457584007913129639935; + + StdStorage internal stdstore; + + /*////////////////////////////////////////////////////////////////////////// + STD-LOGS + //////////////////////////////////////////////////////////////////////////*/ + + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + + /*////////////////////////////////////////////////////////////////////////// + STD-CHEATS + //////////////////////////////////////////////////////////////////////////*/ + + // Skip forward or rewind time by the specified number of seconds + function skip(uint256 time) internal { + vm.warp(block.timestamp + time); + } + + function rewind(uint256 time) internal { + vm.warp(block.timestamp - time); + } + + // Setup a prank from an address that has some ether + function hoax(address who) internal { + vm.deal(who, 1 << 128); + vm.prank(who); + } + + function hoax(address who, uint256 give) internal { + vm.deal(who, give); + vm.prank(who); + } + + function hoax(address who, address origin) internal { + vm.deal(who, 1 << 128); + vm.prank(who, origin); + } + + function hoax(address who, address origin, uint256 give) internal { + vm.deal(who, give); + vm.prank(who, origin); + } + + // Start perpetual prank from an address that has some ether + function startHoax(address who) internal { + vm.deal(who, 1 << 128); + vm.startPrank(who); + } + + function startHoax(address who, uint256 give) internal { + vm.deal(who, give); + vm.startPrank(who); + } + + // Start perpetual prank from an address that has some ether + // tx.origin is set to the origin parameter + function startHoax(address who, address origin) internal { + vm.deal(who, 1 << 128); + vm.startPrank(who, origin); + } + + function startHoax(address who, address origin, uint256 give) internal { + vm.deal(who, give); + vm.startPrank(who, origin); + } + + function changePrank(address who) internal { + vm.stopPrank(); + vm.startPrank(who); + } + + // creates a labeled address and the corresponding private key + function makeAddrAndKey(string memory name) internal returns(address addr, uint256 privateKey) { + privateKey = uint256(keccak256(abi.encodePacked(name))); + addr = vm.addr(privateKey); + vm.label(addr, name); + } + + // creates a labeled address + function makeAddr(string memory name) internal returns(address addr) { + (addr,) = makeAddrAndKey(name); + } + + // DEPRECATED: Use `deal` instead + function tip(address token, address to, uint256 give) internal { + emit log_named_string("WARNING", "Test tip(address,address,uint256): The `tip` stdcheat has been deprecated. Use `deal` instead."); + stdstore + .target(token) + .sig(0x70a08231) + .with_key(to) + .checked_write(give); + } + + // The same as Vm's `deal` + // Use the alternative signature for ERC20 tokens + function deal(address to, uint256 give) internal { + vm.deal(to, give); + } + + // Set the balance of an account for any ERC20 token + // Use the alternative signature to update `totalSupply` + function deal(address token, address to, uint256 give) internal { + deal(token, to, give, false); + } + + function deal(address token, address to, uint256 give, bool adjust) internal { + // get current balance + (, bytes memory balData) = token.call(abi.encodeWithSelector(0x70a08231, to)); + uint256 prevBal = abi.decode(balData, (uint256)); + + // update balance + stdstore + .target(token) + .sig(0x70a08231) + .with_key(to) + .checked_write(give); + + // update total supply + if(adjust){ + (, bytes memory totSupData) = token.call(abi.encodeWithSelector(0x18160ddd)); + uint256 totSup = abi.decode(totSupData, (uint256)); + if(give < prevBal) { + totSup -= (prevBal - give); + } else { + totSup += (give - prevBal); + } + stdstore + .target(token) + .sig(0x18160ddd) + .checked_write(totSup); + } + } + + function bound(uint256 x, uint256 min, uint256 max) internal virtual returns (uint256 result) { + require(min <= max, "Test bound(uint256,uint256,uint256): Max is less than min."); + + uint256 size = max - min; + + if (size == 0) + { + result = min; + } + else if (size == UINT256_MAX) + { + result = x; + } + else + { + ++size; // make `max` inclusive + uint256 mod = x % size; + result = min + mod; + } + + emit log_named_uint("Bound Result", result); + } + + // Deploy a contract by fetching the contract bytecode from + // the artifacts directory + // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))` + function deployCode(string memory what, bytes memory args) + internal + returns (address addr) + { + bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); + /// @solidity memory-safe-assembly + assembly { + addr := create(0, add(bytecode, 0x20), mload(bytecode)) + } + + require( + addr != address(0), + "Test deployCode(string,bytes): Deployment failed." + ); + } + + function deployCode(string memory what) + internal + returns (address addr) + { + bytes memory bytecode = vm.getCode(what); + /// @solidity memory-safe-assembly + assembly { + addr := create(0, add(bytecode, 0x20), mload(bytecode)) + } + + require( + addr != address(0), + "Test deployCode(string): Deployment failed." + ); + } + + /// deploy contract with value on construction + function deployCode(string memory what, bytes memory args, uint256 val) + internal + returns (address addr) + { + bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); + /// @solidity memory-safe-assembly + assembly { + addr := create(val, add(bytecode, 0x20), mload(bytecode)) + } + + require( + addr != address(0), + "Test deployCode(string,bytes,uint256): Deployment failed." + ); + } + + function deployCode(string memory what, uint256 val) + internal + returns (address addr) + { + bytes memory bytecode = vm.getCode(what); + /// @solidity memory-safe-assembly + assembly { + addr := create(val, add(bytecode, 0x20), mload(bytecode)) + } + + require( + addr != address(0), + "Test deployCode(string,uint256): Deployment failed." + ); + } + + /*////////////////////////////////////////////////////////////////////////// + STD-ASSERTIONS + //////////////////////////////////////////////////////////////////////////*/ + + function fail(string memory err) internal virtual { + emit log_named_string("Error", err); + fail(); + } + + function assertFalse(bool data) internal virtual { + assertTrue(!data); + } + + function assertFalse(bool data, string memory err) internal virtual { + assertTrue(!data, err); + } + + function assertEq(bool a, bool b) internal { + if (a != b) { + emit log ("Error: a == b not satisfied [bool]"); + emit log_named_string (" Expected", b ? "true" : "false"); + emit log_named_string (" Actual", a ? "true" : "false"); + fail(); + } + } + + function assertEq(bool a, bool b, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEq(bytes memory a, bytes memory b) internal { + assertEq0(a, b); + } + + function assertEq(bytes memory a, bytes memory b, string memory err) internal { + assertEq0(a, b, err); + } + + function assertEq(uint256[] memory a, uint256[] memory b) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [uint[]]"); + emit log_named_array(" Expected", b); + emit log_named_array(" Actual", a); + fail(); + } + } + + function assertEq(int256[] memory a, int256[] memory b) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [int[]]"); + emit log_named_array(" Expected", b); + emit log_named_array(" Actual", a); + fail(); + } + } + + function assertEq(address[] memory a, address[] memory b) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [address[]]"); + emit log_named_array(" Expected", b); + emit log_named_array(" Actual", a); + fail(); + } + } + + function assertEq(uint256[] memory a, uint256[] memory b, string memory err) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEq(int256[] memory a, int256[] memory b, string memory err) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + + function assertEq(address[] memory a, address[] memory b, string memory err) internal { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEqUint(uint256 a, uint256 b) internal { + assertEq(uint256(a), uint256(b)); + } + + function assertApproxEqAbs( + uint256 a, + uint256 b, + uint256 maxDelta + ) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log ("Error: a ~= b not satisfied [uint]"); + emit log_named_uint (" Expected", b); + emit log_named_uint (" Actual", a); + emit log_named_uint (" Max Delta", maxDelta); + emit log_named_uint (" Delta", delta); + fail(); + } + } + + function assertApproxEqAbs( + uint256 a, + uint256 b, + uint256 maxDelta, + string memory err + ) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string ("Error", err); + assertApproxEqAbs(a, b, maxDelta); + } + } + + function assertApproxEqAbs( + int256 a, + int256 b, + uint256 maxDelta + ) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log ("Error: a ~= b not satisfied [int]"); + emit log_named_int (" Expected", b); + emit log_named_int (" Actual", a); + emit log_named_uint (" Max Delta", maxDelta); + emit log_named_uint (" Delta", delta); + fail(); + } + } + + function assertApproxEqAbs( + int256 a, + int256 b, + uint256 maxDelta, + string memory err + ) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string ("Error", err); + assertApproxEqAbs(a, b, maxDelta); + } + } + + function assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100% + ) internal virtual { + if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log ("Error: a ~= b not satisfied [uint]"); + emit log_named_uint (" Expected", b); + emit log_named_uint (" Actual", a); + emit log_named_decimal_uint (" Max % Delta", maxPercentDelta, 18); + emit log_named_decimal_uint (" % Delta", percentDelta, 18); + fail(); + } + } + + function assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% + string memory err + ) internal virtual { + if (b == 0) return assertEq(a, b, err); // If the expected is 0, actual must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string ("Error", err); + assertApproxEqRel(a, b, maxPercentDelta); + } + } + + function assertApproxEqRel( + int256 a, + int256 b, + uint256 maxPercentDelta + ) internal virtual { + if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log ("Error: a ~= b not satisfied [int]"); + emit log_named_int (" Expected", b); + emit log_named_int (" Actual", a); + emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18); + emit log_named_decimal_uint(" % Delta", percentDelta, 18); + fail(); + } + } + + function assertApproxEqRel( + int256 a, + int256 b, + uint256 maxPercentDelta, + string memory err + ) internal virtual { + if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string ("Error", err); + assertApproxEqRel(a, b, maxPercentDelta); + } + } + + /*////////////////////////////////////////////////////////////// + JSON PARSING + //////////////////////////////////////////////////////////////*/ + + // Data structures to parse Transaction objects from the broadcast artifact + // that conform to EIP1559. The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct RawTx1559 { + string[] arguments; + address contractAddress; + string contractName; + // json value name = function + string functionSig; + bytes32 hash; + // json value name = tx + RawTx1559Detail txDetail; + // json value name = type + string opcode; + } + + struct RawTx1559Detail { + AccessList[] accessList; + bytes data; + address from; + bytes gas; + bytes nonce; + address to; + bytes txType; + bytes value; + } + + struct Tx1559 { + string[] arguments; + address contractAddress; + string contractName; + string functionSig; + bytes32 hash; + Tx1559Detail txDetail; + string opcode; + } + + struct Tx1559Detail { + AccessList[] accessList; + bytes data; + address from; + uint256 gas; + uint256 nonce; + address to; + uint256 txType; + uint256 value; + } + + // Data structures to parse Transaction objects from the broadcast artifact + // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct TxLegacy{ + string[] arguments; + address contractAddress; + string contractName; + string functionSig; + string hash; + string opcode; + TxDetailLegacy transaction; + } + + struct TxDetailLegacy{ + AccessList[] accessList; + uint256 chainId; + bytes data; + address from; + uint256 gas; + uint256 gasPrice; + bytes32 hash; + uint256 nonce; + bytes1 opcode; + bytes32 r; + bytes32 s; + uint256 txType; + address to; + uint8 v; + uint256 value; + } + + struct AccessList{ + address accessAddress; + bytes32[] storageKeys; + } + + // Data structures to parse Receipt objects from the broadcast artifact. + // The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct RawReceipt { + bytes32 blockHash; + bytes blockNumber; + address contractAddress; + bytes cumulativeGasUsed; + bytes effectiveGasPrice; + address from; + bytes gasUsed; + RawReceiptLog[] logs; + bytes logsBloom; + bytes status; + address to; + bytes32 transactionHash; + bytes transactionIndex; + } + + struct Receipt { + bytes32 blockHash; + uint256 blockNumber; + address contractAddress; + uint256 cumulativeGasUsed; + uint256 effectiveGasPrice; + address from; + uint256 gasUsed; + ReceiptLog[] logs; + bytes logsBloom; + uint256 status; + address to; + bytes32 transactionHash; + uint256 transactionIndex; + } + + // Data structures to parse the entire broadcast artifact, assuming the + // transactions conform to EIP1559. + + struct EIP1559ScriptArtifact { + string[] libraries; + string path; + string[] pending; + Receipt[] receipts; + uint256 timestamp; + Tx1559[] transactions; + TxReturn[] txReturns; + } + + struct RawEIP1559ScriptArtifact { + string[] libraries; + string path; + string[] pending; + RawReceipt[] receipts; + TxReturn[] txReturns; + uint256 timestamp; + RawTx1559[] transactions; + } + + struct RawReceiptLog { + // json value = address + address logAddress; + bytes32 blockHash; + bytes blockNumber; + bytes data; + bytes logIndex; + bool removed; + bytes32[] topics; + bytes32 transactionHash; + bytes transactionIndex; + bytes transactionLogIndex; + } + + struct ReceiptLog { + // json value = address + address logAddress; + bytes32 blockHash; + uint256 blockNumber; + bytes data; + uint256 logIndex; + bytes32[] topics; + uint256 transactionIndex; + uint256 transactionLogIndex; + bool removed; + } + + struct TxReturn { + string internalType; + string value; + } + + + function readEIP1559ScriptArtifact(string memory path) + internal + returns(EIP1559ScriptArtifact memory) + { + string memory data = vm.readFile(path); + bytes memory parsedData = vm.parseJson(data); + RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact)); + EIP1559ScriptArtifact memory artifact; + artifact.libraries = rawArtifact.libraries; + artifact.path = rawArtifact.path; + artifact.timestamp = rawArtifact.timestamp; + artifact.pending = rawArtifact.pending; + artifact.txReturns = rawArtifact.txReturns; + artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts); + artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions); + return artifact; + } + + function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) + internal pure + returns (Tx1559[] memory) + { + Tx1559[] memory txs = new Tx1559[](rawTxs.length); + for (uint i; i < rawTxs.length; i++) { + txs[i] = rawToConvertedEIPTx1559(rawTxs[i]); + } + return txs; + } + + function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) + internal pure + returns (Tx1559 memory) + { + Tx1559 memory transaction; + transaction.arguments = rawTx.arguments; + transaction.contractName = rawTx.contractName; + transaction.functionSig = rawTx.functionSig; + transaction.hash= rawTx.hash; + transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail); + transaction.opcode= rawTx.opcode; + return transaction; + } + + function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail) + internal pure + returns (Tx1559Detail memory) + { + Tx1559Detail memory txDetail; + txDetail.data = rawDetail.data; + txDetail.from = rawDetail.from; + txDetail.to = rawDetail.to; + txDetail.nonce = bytesToUint(rawDetail.nonce); + txDetail.txType = bytesToUint(rawDetail.txType); + txDetail.value = bytesToUint(rawDetail.value); + txDetail.gas = bytesToUint(rawDetail.gas); + txDetail.accessList = rawDetail.accessList; + return txDetail; + + } + + function readTx1559s(string memory path) + internal + returns (Tx1559[] memory) + { + string memory deployData = vm.readFile(path); + bytes memory parsedDeployData = + vm.parseJson(deployData, ".transactions"); + RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[])); + return rawToConvertedEIPTx1559s(rawTxs); + } + + + function readTx1559(string memory path, uint256 index) + internal + returns (Tx1559 memory) + { + string memory deployData = vm.readFile(path); + string memory key = string(abi.encodePacked(".transactions[",vm.toString(index), "]")); + bytes memory parsedDeployData = + vm.parseJson(deployData, key); + RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559)); + return rawToConvertedEIPTx1559(rawTx); + } + + + // Analogous to readTransactions, but for receipts. + function readReceipts(string memory path) + internal + returns (Receipt[] memory) + { + string memory deployData = vm.readFile(path); + bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts"); + RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[])); + return rawToConvertedReceipts(rawReceipts); + } + + function readReceipt(string memory path, uint index) + internal + returns (Receipt memory) + { + string memory deployData = vm.readFile(path); + string memory key = string(abi.encodePacked(".receipts[",vm.toString(index), "]")); + bytes memory parsedDeployData = vm.parseJson(deployData, key); + RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt)); + return rawToConvertedReceipt(rawReceipt); + } + + function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) + internal pure + returns(Receipt[] memory) + { + Receipt[] memory receipts = new Receipt[](rawReceipts.length); + for (uint i; i < rawReceipts.length; i++) { + receipts[i] = rawToConvertedReceipt(rawReceipts[i]); + } + return receipts; + } + + function rawToConvertedReceipt(RawReceipt memory rawReceipt) + internal pure + returns(Receipt memory) + { + Receipt memory receipt; + receipt.blockHash = rawReceipt.blockHash; + receipt.to = rawReceipt.to; + receipt.from = rawReceipt.from; + receipt.contractAddress = rawReceipt.contractAddress; + receipt.effectiveGasPrice = bytesToUint(rawReceipt.effectiveGasPrice); + receipt.cumulativeGasUsed= bytesToUint(rawReceipt.cumulativeGasUsed); + receipt.gasUsed = bytesToUint(rawReceipt.gasUsed); + receipt.status = bytesToUint(rawReceipt.status); + receipt.transactionIndex = bytesToUint(rawReceipt.transactionIndex); + receipt.blockNumber = bytesToUint(rawReceipt.blockNumber); + receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs); + receipt.logsBloom = rawReceipt.logsBloom; + receipt.transactionHash = rawReceipt.transactionHash; + return receipt; + } + + function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs) + internal pure + returns (ReceiptLog[] memory) + { + ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length); + for (uint i; i < rawLogs.length; i++) { + logs[i].logAddress = rawLogs[i].logAddress; + logs[i].blockHash = rawLogs[i].blockHash; + logs[i].blockNumber = bytesToUint(rawLogs[i].blockNumber); + logs[i].data = rawLogs[i].data; + logs[i].logIndex = bytesToUint(rawLogs[i].logIndex); + logs[i].topics = rawLogs[i].topics; + logs[i].transactionIndex = bytesToUint(rawLogs[i].transactionIndex); + logs[i].transactionLogIndex = bytesToUint(rawLogs[i].transactionLogIndex); + logs[i].removed = rawLogs[i].removed; + } + return logs; + + } + + function bytesToUint(bytes memory b) internal pure returns (uint256){ + uint256 number; + for (uint i=0; i < b.length; i++) { + number = number + uint(uint8(b[i]))*(2**(8*(b.length-(i+1)))); + } + return number; + } + +} + +/*////////////////////////////////////////////////////////////////////////// + STD-ERRORS +//////////////////////////////////////////////////////////////////////////*/ + +library stdError { + bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01); + bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11); + bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12); + bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21); + bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22); + bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31); + bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32); + bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41); + bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51); + // DEPRECATED: Use Vm's `expectRevert` without any arguments instead + bytes public constant lowLevelError = bytes(""); // `0x` +} + +/*////////////////////////////////////////////////////////////////////////// + STD-STORAGE +//////////////////////////////////////////////////////////////////////////*/ + +struct StdStorage { + mapping (address => mapping(bytes4 => mapping(bytes32 => uint256))) slots; + mapping (address => mapping(bytes4 => mapping(bytes32 => bool))) finds; + + bytes32[] _keys; + bytes4 _sig; + uint256 _depth; + address _target; + bytes32 _set; +} + +library stdStorage { + event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint slot); + event WARNING_UninitedSlot(address who, uint slot); + + uint256 private constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935; + int256 private constant INT256_MAX = 57896044618658097711785492504343953926634992332820282019728792003956564819967; + + Vm private constant vm_std_store = Vm(address(uint160(uint256(keccak256('hevm cheat code'))))); + + function sigs( + string memory sigStr + ) + internal + pure + returns (bytes4) + { + return bytes4(keccak256(bytes(sigStr))); + } + + /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against + // slot complexity: + // if flat, will be bytes32(uint256(uint)); + // if map, will be keccak256(abi.encode(key, uint(slot))); + // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot))))); + // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth); + function find( + StdStorage storage self + ) + internal + returns (uint256) + { + address who = self._target; + bytes4 fsig = self._sig; + uint256 field_depth = self._depth; + bytes32[] memory ins = self._keys; + + // calldata to test against + if (self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) { + return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]; + } + bytes memory cald = abi.encodePacked(fsig, flatten(ins)); + vm_std_store.record(); + bytes32 fdat; + { + (, bytes memory rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32*field_depth); + } + + (bytes32[] memory reads, ) = vm_std_store.accesses(address(who)); + if (reads.length == 1) { + bytes32 curr = vm_std_store.load(who, reads[0]); + if (curr == bytes32(0)) { + emit WARNING_UninitedSlot(who, uint256(reads[0])); + } + if (fdat != curr) { + require(false, "stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported."); + } + emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[0])); + self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[0]); + self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true; + } else if (reads.length > 1) { + for (uint256 i = 0; i < reads.length; i++) { + bytes32 prev = vm_std_store.load(who, reads[i]); + if (prev == bytes32(0)) { + emit WARNING_UninitedSlot(who, uint256(reads[i])); + } + // store + vm_std_store.store(who, reads[i], bytes32(hex"1337")); + bool success; + bytes memory rdat; + { + (success, rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32*field_depth); + } + + if (success && fdat == bytes32(hex"1337")) { + // we found which of the slots is the actual one + emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[i])); + self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[i]); + self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true; + vm_std_store.store(who, reads[i], prev); + break; + } + vm_std_store.store(who, reads[i], prev); + } + } else { + require(false, "stdStorage find(StdStorage): No storage use detected for target."); + } + + require(self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))], "stdStorage find(StdStorage): Slot(s) not found."); + + delete self._target; + delete self._sig; + delete self._keys; + delete self._depth; + + return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]; + } + + function target(StdStorage storage self, address _target) internal returns (StdStorage storage) { + self._target = _target; + return self; + } + + function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) { + self._sig = _sig; + return self; + } + + function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) { + self._sig = sigs(_sig); + return self; + } + + function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) { + self._keys.push(bytes32(uint256(uint160(who)))); + return self; + } + + function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) { + self._keys.push(bytes32(amt)); + return self; + } + function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) { + self._keys.push(key); + return self; + } + + function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) { + self._depth = _depth; + return self; + } + + function checked_write(StdStorage storage self, address who) internal { + checked_write(self, bytes32(uint256(uint160(who)))); + } + + function checked_write(StdStorage storage self, uint256 amt) internal { + checked_write(self, bytes32(amt)); + } + + function checked_write(StdStorage storage self, bool write) internal { + bytes32 t; + /// @solidity memory-safe-assembly + assembly { + t := write + } + checked_write(self, t); + } + + function checked_write( + StdStorage storage self, + bytes32 set + ) internal { + address who = self._target; + bytes4 fsig = self._sig; + uint256 field_depth = self._depth; + bytes32[] memory ins = self._keys; + + bytes memory cald = abi.encodePacked(fsig, flatten(ins)); + if (!self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) { + find(self); + } + bytes32 slot = bytes32(self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]); + + bytes32 fdat; + { + (, bytes memory rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32*field_depth); + } + bytes32 curr = vm_std_store.load(who, slot); + + if (fdat != curr) { + require(false, "stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported."); + } + vm_std_store.store(who, slot, set); + delete self._target; + delete self._sig; + delete self._keys; + delete self._depth; + } + + function read(StdStorage storage self) private returns (bytes memory) { + address t = self._target; + uint256 s = find(self); + return abi.encode(vm_std_store.load(t, bytes32(s))); + } + + function read_bytes32(StdStorage storage self) internal returns (bytes32) { + return abi.decode(read(self), (bytes32)); + } + + + function read_bool(StdStorage storage self) internal returns (bool) { + int256 v = read_int(self); + if (v == 0) return false; + if (v == 1) return true; + revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool."); + } + + function read_address(StdStorage storage self) internal returns (address) { + return abi.decode(read(self), (address)); + } + + function read_uint(StdStorage storage self) internal returns (uint256) { + return abi.decode(read(self), (uint256)); + } + + function read_int(StdStorage storage self) internal returns (int256) { + return abi.decode(read(self), (int256)); + } + + function bytesToBytes32(bytes memory b, uint offset) public pure returns (bytes32) { + bytes32 out; + + uint256 max = b.length > 32 ? 32 : b.length; + for (uint i = 0; i < max; i++) { + out |= bytes32(b[offset + i] & 0xFF) >> (i * 8); + } + return out; + } + + function flatten(bytes32[] memory b) private pure returns (bytes memory) + { + bytes memory result = new bytes(b.length * 32); + for (uint256 i = 0; i < b.length; i++) { + bytes32 k = b[i]; + /// @solidity memory-safe-assembly + assembly { + mstore(add(result, add(32, mul(32, i))), k) + } + } + + return result; + } + + + +} + + +/*////////////////////////////////////////////////////////////////////////// + STD-MATH +//////////////////////////////////////////////////////////////////////////*/ + +library stdMath { + int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968; + + function abs(int256 a) internal pure returns (uint256) { + // Required or it will fail when `a = type(int256).min` + if (a == INT256_MIN) + return 57896044618658097711785492504343953926634992332820282019728792003956564819968; + + return uint256(a > 0 ? a : -a); + } + + function delta(uint256 a, uint256 b) internal pure returns (uint256) { + return a > b + ? a - b + : b - a; + } + + function delta(int256 a, int256 b) internal pure returns (uint256) { + // a and b are of the same sign + // this works thanks to two's complement, the left-most bit is the sign bit + if ((a ^ b) > -1) { + return delta(abs(a), abs(b)); + } + + // a and b are of opposite signs + return abs(a) + abs(b); + } + + function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 absDelta = delta(a, b); + + return absDelta * 1e18 / b; + } + + function percentDelta(int256 a, int256 b) internal pure returns (uint256) { + uint256 absDelta = delta(a, b); + uint256 absB = abs(b); + + return absDelta * 1e18 / absB; + } +} diff --git a/lib/forge-std/src/Vm.sol b/lib/forge-std/src/Vm.sol new file mode 100644 index 0000000..4aeb676 --- /dev/null +++ b/lib/forge-std/src/Vm.sol @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; +pragma experimental ABIEncoderV2; + +interface Vm { + struct Log { + bytes32[] topics; + bytes data; + } + + // Sets block.timestamp (newTimestamp) + function warp(uint256) external; + // Sets block.height (newHeight) + function roll(uint256) external; + // Sets block.basefee (newBasefee) + function fee(uint256) external; + // Sets block.difficulty (newDifficulty) + function difficulty(uint256) external; + // Sets block.chainid + function chainId(uint256) external; + // Loads a storage slot from an address (who, slot) + function load(address,bytes32) external returns (bytes32); + // Stores a value to an address' storage slot, (who, slot, value) + function store(address,bytes32,bytes32) external; + // Signs data, (privateKey, digest) => (v, r, s) + function sign(uint256,bytes32) external returns (uint8,bytes32,bytes32); + // Gets the address for a given private key, (privateKey) => (address) + function addr(uint256) external returns (address); + // Gets the nonce of an account + function getNonce(address) external returns (uint64); + // Sets the nonce of an account; must be higher than the current nonce of the account + function setNonce(address, uint64) external; + // Performs a foreign function call via the terminal, (stringInputs) => (result) + function ffi(string[] calldata) external returns (bytes memory); + // Sets environment variables, (name, value) + function setEnv(string calldata, string calldata) external; + // Reads environment variables, (name) => (value) + function envBool(string calldata) external returns (bool); + function envUint(string calldata) external returns (uint256); + function envInt(string calldata) external returns (int256); + function envAddress(string calldata) external returns (address); + function envBytes32(string calldata) external returns (bytes32); + function envString(string calldata) external returns (string memory); + function envBytes(string calldata) external returns (bytes memory); + // Reads environment variables as arrays, (name, delim) => (value[]) + function envBool(string calldata, string calldata) external returns (bool[] memory); + function envUint(string calldata, string calldata) external returns (uint256[] memory); + function envInt(string calldata, string calldata) external returns (int256[] memory); + function envAddress(string calldata, string calldata) external returns (address[] memory); + function envBytes32(string calldata, string calldata) external returns (bytes32[] memory); + function envString(string calldata, string calldata) external returns (string[] memory); + function envBytes(string calldata, string calldata) external returns (bytes[] memory); + // Sets the *next* call's msg.sender to be the input address + function prank(address) external; + // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called + function startPrank(address) external; + // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input + function prank(address,address) external; + // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input + function startPrank(address,address) external; + // Resets subsequent calls' msg.sender to be `address(this)` + function stopPrank() external; + // Sets an address' balance, (who, newBalance) + function deal(address, uint256) external; + // Sets an address' code, (who, newCode) + function etch(address, bytes calldata) external; + // Expects an error on next call + function expectRevert(bytes calldata) external; + function expectRevert(bytes4) external; + function expectRevert() external; + // Records all storage reads and writes + function record() external; + // Gets all accessed reads and write slot from a recording session, for a given address + function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes); + // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData). + // Call this function, then emit an event, then call a function. Internally after the call, we check if + // logs were emitted in the expected order with the expected topics and data (as specified by the booleans) + function expectEmit(bool,bool,bool,bool) external; + function expectEmit(bool,bool,bool,bool,address) external; + // Mocks a call to an address, returning specified data. + // Calldata can either be strict or a partial match, e.g. if you only + // pass a Solidity selector to the expected calldata, then the entire Solidity + // function will be mocked. + function mockCall(address,bytes calldata,bytes calldata) external; + // Mocks a call to an address with a specific msg.value, returning specified data. + // Calldata match takes precedence over msg.value in case of ambiguity. + function mockCall(address,uint256,bytes calldata,bytes calldata) external; + // Clears all mocked calls + function clearMockedCalls() external; + // Expects a call to an address with the specified calldata. + // Calldata can either be a strict or a partial match + function expectCall(address,bytes calldata) external; + // Expects a call to an address with the specified msg.value and calldata + function expectCall(address,uint256,bytes calldata) external; + // Gets the code from an artifact file. Takes in the relative path to the json file + function getCode(string calldata) external returns (bytes memory); + // Labels an address in call traces + function label(address, string calldata) external; + // If the condition is false, discard this run's fuzz inputs and generate new ones + function assume(bool) external; + // Sets block.coinbase (who) + function coinbase(address) external; + // Using the address that calls the test contract, has the next call (at this call depth only) create a transaction that can later be signed and sent onchain + function broadcast() external; + // Has the next call (at this call depth only) create a transaction with the address provided as the sender that can later be signed and sent onchain + function broadcast(address) external; + // Has the next call (at this call depth only) create a transaction with the private key provided as the sender that can later be signed and sent onchain + function broadcast(uint256) external; + // Using the address that calls the test contract, has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain + function startBroadcast() external; + // Has all subsequent calls (at this call depth only) create transactions with the address provided that can later be signed and sent onchain + function startBroadcast(address) external; + // Has all subsequent calls (at this call depth only) create transactions with the private key provided that can later be signed and sent onchain + function startBroadcast(uint256) external; + // Stops collecting onchain transactions + function stopBroadcast() external; + + // Reads the entire content of file to string, (path) => (data) + function readFile(string calldata) external returns (string memory); + // Get the path of the current project root + function projectRoot() external returns (string memory); + // Reads next line of file to string, (path) => (line) + function readLine(string calldata) external returns (string memory); + // Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does. + // (path, data) => () + function writeFile(string calldata, string calldata) external; + // Writes line to file, creating a file if it does not exist. + // (path, data) => () + function writeLine(string calldata, string calldata) external; + // Closes file for reading, resetting the offset and allowing to read it from beginning with readLine. + // (path) => () + function closeFile(string calldata) external; + // Removes file. This cheatcode will revert in the following situations, but is not limited to just these cases: + // - Path points to a directory. + // - The file doesn't exist. + // - The user lacks permissions to remove the file. + // (path) => () + function removeFile(string calldata) external; + + // Convert values to a string, (value) => (stringified value) + function toString(address) external returns(string memory); + function toString(bytes calldata) external returns(string memory); + function toString(bytes32) external returns(string memory); + function toString(bool) external returns(string memory); + function toString(uint256) external returns(string memory); + function toString(int256) external returns(string memory); + + // Convert values from a string, (string) => (parsed value) + function parseBytes(string calldata) external returns (bytes memory); + function parseAddress(string calldata) external returns (address); + function parseUint(string calldata) external returns (uint256); + function parseInt(string calldata) external returns (int256); + function parseBytes32(string calldata) external returns (bytes32); + function parseBool(string calldata) external returns (bool); + + // Record all the transaction logs + function recordLogs() external; + // Gets all the recorded logs, () => (logs) + function getRecordedLogs() external returns (Log[] memory); + // Snapshot the current state of the evm. + // Returns the id of the snapshot that was created. + // To revert a snapshot use `revertTo` + function snapshot() external returns(uint256); + // Revert the state of the evm to a previous snapshot + // Takes the snapshot id to revert to. + // This deletes the snapshot and all snapshots taken after the given snapshot id. + function revertTo(uint256) external returns(bool); + + // Creates a new fork with the given endpoint and block and returns the identifier of the fork + function createFork(string calldata,uint256) external returns(uint256); + // Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork + function createFork(string calldata) external returns(uint256); + // Creates _and_ also selects a new fork with the given endpoint and block and returns the identifier of the fork + function createSelectFork(string calldata,uint256) external returns(uint256); + // Creates _and_ also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork + function createSelectFork(string calldata) external returns(uint256); + // Takes a fork identifier created by `createFork` and sets the corresponding forked state as active. + function selectFork(uint256) external; + /// Returns the currently active fork + /// Reverts if no fork is currently active + function activeFork() external returns(uint256); + // Updates the currently active fork to given block number + // This is similar to `roll` but for the currently active fork + function rollFork(uint256) external; + // Updates the given fork to given block number + function rollFork(uint256 forkId, uint256 blockNumber) external; + + // Marks that the account(s) should use persistent storage across fork swaps in a multifork setup + // Meaning, changes made to the state of this account will be kept when switching forks + function makePersistent(address) external; + function makePersistent(address, address) external; + function makePersistent(address, address, address) external; + function makePersistent(address[] calldata) external; + // Revokes persistent status from the address, previously added via `makePersistent` + function revokePersistent(address) external; + function revokePersistent(address[] calldata) external; + // Returns true if the account is marked as persistent + function isPersistent(address) external returns (bool); + + // Returns the RPC url for the given alias + function rpcUrl(string calldata) external returns(string memory); + // Returns all rpc urls and their aliases `[alias, url][]` + function rpcUrls() external returns(string[2][] memory); + + // Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path m/44'/60'/0'/0/{index} + function deriveKey(string calldata, uint32) external returns (uint256); + // Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path {path}{index} + function deriveKey(string calldata, string calldata, uint32) external returns (uint256); + // Adds a private key to the local forge wallet and returns the address + function rememberKey(uint256) external returns (address); + + // parseJson + + // Given a string of JSON, return the ABI-encoded value of provided key + // (stringified json, key) => (ABI-encoded data) + // Read the note below! + function parseJson(string calldata, string calldata) external returns(bytes memory); + + // Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data) + // Read the note below! + function parseJson(string calldata) external returns(bytes memory); + + // Note: + // ---- + // In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects + // don't have the notion of ordered, but tuples do, they JSON object is encoded with it's fields ordered in + // ALPHABETICAL ordser. That means that in order to succesfully decode the tuple, we need to define a tuple that + // encodes the fields in the same order, which is alphabetical. In the case of Solidity structs, they are encoded + // as tuples, with the attributes in the order in which they are defined. + // For example: json = { 'a': 1, 'b': 0xa4tb......3xs} + // a: uint256 + // b: address + // To decode that json, we need to define a struct or a tuple as follows: + // struct json = { uint256 a; address b; } + // If we defined a json struct with the opposite order, meaning placing the address b first, it would try to + // decode the tuple in that order, and thus fail. + +} diff --git a/lib/forge-std/src/console.sol b/lib/forge-std/src/console.sol new file mode 100644 index 0000000..ad57e53 --- /dev/null +++ b/lib/forge-std/src/console.sol @@ -0,0 +1,1533 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.4.22 <0.9.0; + +library console { + address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67); + + function _sendLogPayload(bytes memory payload) private view { + uint256 payloadLength = payload.length; + address consoleAddress = CONSOLE_ADDRESS; + /// @solidity memory-safe-assembly + assembly { + let payloadStart := add(payload, 32) + let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) + } + } + + function log() internal view { + _sendLogPayload(abi.encodeWithSignature("log()")); + } + + function logInt(int p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(int)", p0)); + } + + function logUint(uint p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); + } + + function logString(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function logBool(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function logAddress(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function logBytes(bytes memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); + } + + function logBytes1(bytes1 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); + } + + function logBytes2(bytes2 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); + } + + function logBytes3(bytes3 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); + } + + function logBytes4(bytes4 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); + } + + function logBytes5(bytes5 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); + } + + function logBytes6(bytes6 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); + } + + function logBytes7(bytes7 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); + } + + function logBytes8(bytes8 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); + } + + function logBytes9(bytes9 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); + } + + function logBytes10(bytes10 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); + } + + function logBytes11(bytes11 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); + } + + function logBytes12(bytes12 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); + } + + function logBytes13(bytes13 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); + } + + function logBytes14(bytes14 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); + } + + function logBytes15(bytes15 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); + } + + function logBytes16(bytes16 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); + } + + function logBytes17(bytes17 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); + } + + function logBytes18(bytes18 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); + } + + function logBytes19(bytes19 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); + } + + function logBytes20(bytes20 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); + } + + function logBytes21(bytes21 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); + } + + function logBytes22(bytes22 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); + } + + function logBytes23(bytes23 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); + } + + function logBytes24(bytes24 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); + } + + function logBytes25(bytes25 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); + } + + function logBytes26(bytes26 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); + } + + function logBytes27(bytes27 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); + } + + function logBytes28(bytes28 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); + } + + function logBytes29(bytes29 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); + } + + function logBytes30(bytes30 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); + } + + function logBytes31(bytes31 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); + } + + function logBytes32(bytes32 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); + } + + function log(uint p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); + } + + function log(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function log(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function log(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function log(uint p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1)); + } + + function log(uint p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1)); + } + + function log(uint p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1)); + } + + function log(uint p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1)); + } + + function log(string memory p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1)); + } + + function log(string memory p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } + + function log(string memory p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); + } + + function log(string memory p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); + } + + function log(bool p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1)); + } + + function log(bool p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); + } + + function log(bool p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); + } + + function log(bool p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); + } + + function log(address p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1)); + } + + function log(address p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); + } + + function log(address p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); + } + + function log(address p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); + } + + function log(uint p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2)); + } + + function log(uint p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2)); + } + + function log(uint p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2)); + } + + function log(uint p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2)); + } + + function log(uint p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2)); + } + + function log(uint p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2)); + } + + function log(uint p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2)); + } + + function log(uint p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2)); + } + + function log(uint p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2)); + } + + function log(uint p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2)); + } + + function log(uint p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2)); + } + + function log(uint p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); + } + + function log(string memory p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2)); + } + + function log(string memory p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); + } + + function log(string memory p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); + } + + function log(string memory p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); + } + + function log(bool p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2)); + } + + function log(bool p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2)); + } + + function log(bool p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2)); + } + + function log(bool p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); + } + + function log(bool p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2)); + } + + function log(bool p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); + } + + function log(bool p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); + } + + function log(bool p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); + } + + function log(bool p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2)); + } + + function log(bool p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); + } + + function log(bool p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); + } + + function log(bool p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); + } + + function log(address p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2)); + } + + function log(address p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2)); + } + + function log(address p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2)); + } + + function log(address p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2)); + } + + function log(address p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2)); + } + + function log(address p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); + } + + function log(address p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); + } + + function log(address p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); + } + + function log(address p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2)); + } + + function log(address p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); + } + + function log(address p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); + } + + function log(address p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); + } + + function log(address p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2)); + } + + function log(address p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); + } + + function log(address p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); + } + + function log(address p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); + } + + function log(uint p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); + } + +} \ No newline at end of file diff --git a/lib/forge-std/src/console2.sol b/lib/forge-std/src/console2.sol new file mode 100644 index 0000000..2edfda5 --- /dev/null +++ b/lib/forge-std/src/console2.sol @@ -0,0 +1,1538 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.4.22 <0.9.0; + +// The orignal console.sol uses `int` and `uint` for computing function selectors, but it should +// use `int256` and `uint256`. This modified version fixes that. This version is recommended +// over `console.sol` if you don't need compatibility with Hardhat as the logs will show up in +// forge stack traces. If you do need compatibility with Hardhat, you must use `console.sol`. +// Reference: https://github.com/NomicFoundation/hardhat/issues/2178 + +library console2 { + address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67); + + function _sendLogPayload(bytes memory payload) private view { + uint256 payloadLength = payload.length; + address consoleAddress = CONSOLE_ADDRESS; + assembly { + let payloadStart := add(payload, 32) + let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) + } + } + + function log() internal view { + _sendLogPayload(abi.encodeWithSignature("log()")); + } + + function logInt(int256 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); + } + + function logUint(uint256 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } + + function logString(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function logBool(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function logAddress(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function logBytes(bytes memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); + } + + function logBytes1(bytes1 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); + } + + function logBytes2(bytes2 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); + } + + function logBytes3(bytes3 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); + } + + function logBytes4(bytes4 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); + } + + function logBytes5(bytes5 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); + } + + function logBytes6(bytes6 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); + } + + function logBytes7(bytes7 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); + } + + function logBytes8(bytes8 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); + } + + function logBytes9(bytes9 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); + } + + function logBytes10(bytes10 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); + } + + function logBytes11(bytes11 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); + } + + function logBytes12(bytes12 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); + } + + function logBytes13(bytes13 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); + } + + function logBytes14(bytes14 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); + } + + function logBytes15(bytes15 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); + } + + function logBytes16(bytes16 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); + } + + function logBytes17(bytes17 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); + } + + function logBytes18(bytes18 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); + } + + function logBytes19(bytes19 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); + } + + function logBytes20(bytes20 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); + } + + function logBytes21(bytes21 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); + } + + function logBytes22(bytes22 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); + } + + function logBytes23(bytes23 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); + } + + function logBytes24(bytes24 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); + } + + function logBytes25(bytes25 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); + } + + function logBytes26(bytes26 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); + } + + function logBytes27(bytes27 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); + } + + function logBytes28(bytes28 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); + } + + function logBytes29(bytes29 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); + } + + function logBytes30(bytes30 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); + } + + function logBytes31(bytes31 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); + } + + function logBytes32(bytes32 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); + } + + function log(uint256 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } + + function log(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function log(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function log(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function log(uint256 p0, uint256 p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1)); + } + + function log(uint256 p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1)); + } + + function log(uint256 p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1)); + } + + function log(uint256 p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1)); + } + + function log(string memory p0, uint256 p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); + } + + function log(string memory p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } + + function log(string memory p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); + } + + function log(string memory p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); + } + + function log(bool p0, uint256 p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1)); + } + + function log(bool p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); + } + + function log(bool p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); + } + + function log(bool p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); + } + + function log(address p0, uint256 p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1)); + } + + function log(address p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); + } + + function log(address p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); + } + + function log(address p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); + } + + function log(uint256 p0, uint256 p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); + } + + function log(string memory p0, address p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2)); + } + + function log(string memory p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); + } + + function log(string memory p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); + } + + function log(string memory p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); + } + + function log(bool p0, bool p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2)); + } + + function log(bool p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); + } + + function log(bool p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); + } + + function log(bool p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); + } + + function log(bool p0, address p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2)); + } + + function log(bool p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); + } + + function log(bool p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); + } + + function log(bool p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2)); + } + + function log(address p0, string memory p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2)); + } + + function log(address p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); + } + + function log(address p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); + } + + function log(address p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); + } + + function log(address p0, bool p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2)); + } + + function log(address p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); + } + + function log(address p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); + } + + function log(address p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); + } + + function log(address p0, address p1, uint256 p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2)); + } + + function log(address p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); + } + + function log(address p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); + } + + function log(address p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, uint256 p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); + } + +} \ No newline at end of file diff --git a/lib/forge-std/src/test/Script.t.sol b/lib/forge-std/src/test/Script.t.sol new file mode 100644 index 0000000..b26db7f --- /dev/null +++ b/lib/forge-std/src/test/Script.t.sol @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../Test.sol"; + +contract ScriptTest is Test +{ + function testGenerateCorrectAddress() external { + address creation = computeCreateAddress(0x6C9FC64A53c1b71FB3f9Af64d1ae3A4931A5f4E9, 14); + assertEq(creation, 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45); + } + + function testDeriveRememberKey() external { + string memory mnemonic = "test test test test test test test test test test test junk"; + + (address deployer, uint256 privateKey) = deriveRememberKey(mnemonic, 0); + assertEq(deployer, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); + assertEq(privateKey, 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80); + } +} \ No newline at end of file diff --git a/lib/forge-std/src/test/StdAssertions.t.sol b/lib/forge-std/src/test/StdAssertions.t.sol new file mode 100644 index 0000000..3f26f76 --- /dev/null +++ b/lib/forge-std/src/test/StdAssertions.t.sol @@ -0,0 +1,602 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../Test.sol"; + +contract StdAssertionsTest is Test +{ + string constant CUSTOM_ERROR = "guh!"; + + bool constant EXPECT_PASS = false; + bool constant EXPECT_FAIL = true; + + TestTest t = new TestTest(); + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertions() public { + assertEqUint(uint32(1), uint32(1)); + assertEqUint(uint64(1), uint64(1)); + assertEqUint(uint96(1), uint96(1)); + assertEqUint(uint128(1), uint128(1)); + } + + /*////////////////////////////////////////////////////////////////////////// + FAIL(STRING) + //////////////////////////////////////////////////////////////////////////*/ + + function testShouldFail() external { + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._fail(CUSTOM_ERROR); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_FALSE + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertFalse_Pass() external { + t._assertFalse(false, EXPECT_PASS); + } + + function testAssertFalse_Fail() external { + vm.expectEmit(false, false, false, true); + emit log("Error: Assertion Failed"); + t._assertFalse(true, EXPECT_FAIL); + } + + function testAssertFalse_Err_Pass() external { + t._assertFalse(false, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertFalse_Err_Fail() external { + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertFalse(true, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(BOOL) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertEq_Bool_Pass(bool a) external { + t._assertEq(a, a, EXPECT_PASS); + } + + function testAssertEq_Bool_Fail(bool a, bool b) external { + vm.assume(a != b); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [bool]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_BoolErr_Pass(bool a) external { + t._assertEq(a, a, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertEq_BoolErr_Fail(bool a, bool b) external { + vm.assume(a != b); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(BYTES) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertEq_Bytes_Pass(bytes calldata a) external { + t._assertEq(a, a, EXPECT_PASS); + } + + function testAssertEq_Bytes_Fail(bytes calldata a, bytes calldata b) external { + vm.assume(keccak256(a) != keccak256(b)); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [bytes]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_BytesErr_Pass(bytes calldata a) external { + t._assertEq(a, a, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertEq_BytesErr_Fail(bytes calldata a, bytes calldata b) external { + vm.assume(keccak256(a) != keccak256(b)); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(ARRAY) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertEq_UintArr_Pass(uint256 e0, uint256 e1, uint256 e2) public { + uint256[] memory a = new uint256[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + uint256[] memory b = new uint256[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testAssertEq_IntArr_Pass(int256 e0, int256 e1, int256 e2) public { + int256[] memory a = new int256[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + int256[] memory b = new int256[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testAssertEq_AddressArr_Pass(address e0, address e1, address e2) public { + address[] memory a = new address[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + address[] memory b = new address[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testAssertEq_UintArr_FailEl(uint256 e1) public { + vm.assume(e1 != 0); + uint256[] memory a = new uint256[](3); + uint256[] memory b = new uint256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_IntArr_FailEl(int256 e1) public { + vm.assume(e1 != 0); + int256[] memory a = new int256[](3); + int256[] memory b = new int256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + + function testAssertEq_AddressArr_FailEl(address e1) public { + vm.assume(e1 != address(0)); + address[] memory a = new address[](3); + address[] memory b = new address[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_UintArrErr_FailEl(uint256 e1) public { + vm.assume(e1 != 0); + uint256[] memory a = new uint256[](3); + uint256[] memory b = new uint256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testAssertEq_IntArrErr_FailEl(int256 e1) public { + vm.assume(e1 != 0); + int256[] memory a = new int256[](3); + int256[] memory b = new int256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + + function testAssertEq_AddressArrErr_FailEl(address e1) public { + vm.assume(e1 != address(0)); + address[] memory a = new address[](3); + address[] memory b = new address[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testAssertEq_UintArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + uint256[] memory a = new uint256[](lenA); + uint256[] memory b = new uint256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_IntArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + int256[] memory a = new int256[](lenA); + int256[] memory b = new int256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_AddressArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + address[] memory a = new address[](lenA); + address[] memory b = new address[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testAssertEq_UintArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + uint256[] memory a = new uint256[](lenA); + uint256[] memory b = new uint256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testAssertEq_IntArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + int256[] memory a = new int256[](lenA); + int256[] memory b = new int256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testAssertEq_AddressArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + address[] memory a = new address[](lenA); + address[] memory b = new address[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertApproxEqAbs_Uint_Pass(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_PASS); + } + + function testAssertApproxEqAbs_Uint_Fail(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_FAIL); + } + + function testAssertApproxEqAbs_UintErr_Pass(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertApproxEqAbs_UintErr_Fail(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertApproxEqAbs_Int_Pass(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_PASS); + } + + function testAssertApproxEqAbs_Int_Fail(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_FAIL); + } + + function testAssertApproxEqAbs_IntErr_Pass(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertApproxEqAbs_IntErr_Fail(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertApproxEqRel_Uint_Pass(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_PASS); + } + + function testAssertApproxEqRel_Uint_Fail(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_FAIL); + } + + function testAssertApproxEqRel_UintErr_Pass(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertApproxEqRel_UintErr_Fail(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertApproxEqRel_Int_Pass(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_PASS); + } + + function testAssertApproxEqRel_Int_Fail(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_FAIL); + } + + function testAssertApproxEqRel_IntErr_Pass(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertApproxEqRel_IntErr_Fail(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_FAIL); + } +} + + +contract TestTest is Test +{ + modifier expectFailure(bool expectFail) { + bool preState = vm.load(HEVM_ADDRESS, bytes32("failed")) != bytes32(0x00); + _; + bool postState = vm.load(HEVM_ADDRESS, bytes32("failed")) != bytes32(0x00); + + if (preState == true) { + return; + } + + if (expectFail) { + require(postState == true, "expected failure not triggered"); + + // unwind the expected failure + vm.store(HEVM_ADDRESS, bytes32("failed"), bytes32(uint256(0x00))); + } else { + require(postState == false, "unexpected failure was triggered"); + } + } + + function _fail(string memory err) external expectFailure(true) { + fail(err); + } + + function _assertFalse(bool data, bool expectFail) external expectFailure(expectFail) { + assertFalse(data); + } + + function _assertFalse(bool data, string memory err, bool expectFail) external expectFailure(expectFail) { + assertFalse(data, err); + } + + function _assertEq(bool a, bool b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(bool a, bool b, string memory err, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + function _assertEq(bytes memory a, bytes memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(bytes memory a, + bytes memory b, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + function _assertEq(uint256[] memory a, uint256[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(int256[] memory a, int256[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(address[] memory a, address[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(uint256[] memory a, uint256[] memory b, string memory err, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + function _assertEq(int256[] memory a, int256[] memory b, string memory err, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + function _assertEq(address[] memory a, address[] memory b, string memory err, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + + function _assertApproxEqAbs( + uint256 a, + uint256 b, + uint256 maxDelta, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbs(a, b, maxDelta); + } + + function _assertApproxEqAbs( + uint256 a, + uint256 b, + uint256 maxDelta, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbs(a, b, maxDelta, err); + } + + function _assertApproxEqAbs( + int256 a, + int256 b, + uint256 maxDelta, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbs(a, b, maxDelta); + } + + function _assertApproxEqAbs( + int256 a, + int256 b, + uint256 maxDelta, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbs(a, b, maxDelta, err); + } + + function _assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRel(a, b, maxPercentDelta); + } + + function _assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRel(a, b, maxPercentDelta, err); + } + + function _assertApproxEqRel( + int256 a, + int256 b, + uint256 maxPercentDelta, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRel(a, b, maxPercentDelta); + } + + function _assertApproxEqRel( + int256 a, + int256 b, + uint256 maxPercentDelta, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRel(a, b, maxPercentDelta, err); + } +} diff --git a/lib/forge-std/src/test/StdCheats.t.sol b/lib/forge-std/src/test/StdCheats.t.sol new file mode 100644 index 0000000..05e240a --- /dev/null +++ b/lib/forge-std/src/test/StdCheats.t.sol @@ -0,0 +1,282 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../Test.sol"; +import "../StdJson.sol"; + +contract StdCheatsTest is Test { + Bar test; + + using stdJson for string; + + function setUp() public { + test = new Bar(); + } + + function testSkip() public { + vm.warp(100); + skip(25); + assertEq(block.timestamp, 125); + } + + function testRewind() public { + vm.warp(100); + rewind(25); + assertEq(block.timestamp, 75); + } + + function testHoax() public { + hoax(address(1337)); + test.bar{value: 100}(address(1337)); + } + + function testHoaxOrigin() public { + hoax(address(1337), address(1337)); + test.origin{value: 100}(address(1337)); + } + + function testHoaxDifferentAddresses() public { + hoax(address(1337), address(7331)); + test.origin{value: 100}(address(1337), address(7331)); + } + + function testStartHoax() public { + startHoax(address(1337)); + test.bar{value: 100}(address(1337)); + test.bar{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } + + function testStartHoaxOrigin() public { + startHoax(address(1337), address(1337)); + test.origin{value: 100}(address(1337)); + test.origin{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } + + function testChangePrank() public { + vm.startPrank(address(1337)); + test.bar(address(1337)); + changePrank(address(0xdead)); + test.bar(address(0xdead)); + changePrank(address(1337)); + test.bar(address(1337)); + vm.stopPrank(); + } + + function testMakeAddrEquivalence() public { + (address addr, ) = makeAddrAndKey("1337"); + assertEq(makeAddr("1337"), addr); + } + + function testMakeAddrSigning() public { + (address addr, uint256 key) = makeAddrAndKey("1337"); + bytes32 hash = keccak256("some_message"); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign(key, hash); + assertEq(ecrecover(hash, v, r, s), addr); + } + + function testDeal() public { + deal(address(this), 1 ether); + assertEq(address(this).balance, 1 ether); + } + + function testDealToken() public { + Bar barToken = new Bar(); + address bar = address(barToken); + deal(bar, address(this), 10000e18); + assertEq(barToken.balanceOf(address(this)), 10000e18); + } + + function testDealTokenAdjustTS() public { + Bar barToken = new Bar(); + address bar = address(barToken); + deal(bar, address(this), 10000e18, true); + assertEq(barToken.balanceOf(address(this)), 10000e18); + assertEq(barToken.totalSupply(), 20000e18); + deal(bar, address(this), 0, true); + assertEq(barToken.balanceOf(address(this)), 0); + assertEq(barToken.totalSupply(), 10000e18); + } + + function testBound() public { + assertEq(bound(5, 0, 4), 0); + assertEq(bound(0, 69, 69), 69); + assertEq(bound(0, 68, 69), 68); + assertEq(bound(10, 150, 190), 160); + assertEq(bound(300, 2800, 3200), 3100); + assertEq(bound(9999, 1337, 6666), 6006); + } + + function testCannotBoundMaxLessThanMin() public { + vm.expectRevert(bytes("Test bound(uint256,uint256,uint256): Max is less than min.")); + bound(5, 100, 10); + } + + function testBound( + uint256 num, + uint256 min, + uint256 max + ) public { + if (min > max) (min, max) = (max, min); + + uint256 bounded = bound(num, min, max); + + assertGe(bounded, min); + assertLe(bounded, max); + } + + function testBoundUint256Max() public { + assertEq(bound(0, type(uint256).max - 1, type(uint256).max), type(uint256).max - 1); + assertEq(bound(1, type(uint256).max - 1, type(uint256).max), type(uint256).max); + } + + function testCannotBoundMaxLessThanMin( + uint256 num, + uint256 min, + uint256 max + ) public { + vm.assume(min > max); + vm.expectRevert(bytes("Test bound(uint256,uint256,uint256): Max is less than min.")); + bound(num, min, max); + } + + function testDeployCode() public { + address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", bytes("")); + assertEq(string(getCode(deployed)), string(getCode(address(this)))); + } + + function testDeployCodeNoArgs() public { + address deployed = deployCode("StdCheats.t.sol:StdCheatsTest"); + assertEq(string(getCode(deployed)), string(getCode(address(this)))); + } + + // We need that payable constructor in order to send ETH on construction + constructor() payable {} + + function testDeployCodeVal() public { + address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", bytes(""), 1 ether); + assertEq(string(getCode(deployed)), string(getCode(address(this)))); + assertEq(deployed.balance, 1 ether); + } + + function testDeployCodeValNoArgs() public { + address deployed = deployCode("StdCheats.t.sol:StdCheatsTest", 1 ether); + assertEq(string(getCode(deployed)), string(getCode(address(this)))); + assertEq(deployed.balance, 1 ether); + } + + // We need this so we can call "this.deployCode" rather than "deployCode" directly + function deployCodeHelper(string memory what) external { + deployCode(what); + } + + function testDeployCodeFail() public { + vm.expectRevert(bytes("Test deployCode(string): Deployment failed.")); + this.deployCodeHelper("StdCheats.t.sol:RevertingContract"); + } + + function getCode(address who) internal view returns (bytes memory o_code) { + /// @solidity memory-safe-assembly + assembly { + // retrieve the size of the code, this needs assembly + let size := extcodesize(who) + // allocate output byte array - this could also be done without assembly + // by using o_code = new bytes(size) + o_code := mload(0x40) + // new "memory end" including padding + mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f)))) + // store length in memory + mstore(o_code, size) + // actually retrieve the code, this needs assembly + extcodecopy(who, add(o_code, 0x20), 0, size) + } + } + + function testBytesToUint() public { + assertEq(3, bytesToUint(hex'03')); + assertEq(2, bytesToUint(hex'02')); + assertEq(255, bytesToUint(hex'ff')); + assertEq(29625, bytesToUint(hex'73b9')); + } + + function testParseJsonTxDetail() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json"); + string memory json = vm.readFile(path); + bytes memory transactionDetails = json.parseRaw(".transactions[0].tx"); + RawTx1559Detail memory rawTxDetail = abi.decode(transactionDetails, (RawTx1559Detail)); + Tx1559Detail memory txDetail = rawToConvertedEIP1559Detail(rawTxDetail); + assertEq(txDetail.from, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); + assertEq(txDetail.to, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512); + assertEq(txDetail.data, hex'23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004'); + assertEq(txDetail.nonce, 3); + assertEq(txDetail.txType, 2); + assertEq(txDetail.gas, 29625); + assertEq(txDetail.value, 0); + } + + function testReadEIP1559Transaction() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json"); + uint256 index = 0; + Tx1559 memory transaction = readTx1559(path, index); + } + + function testReadEIP1559Transactions() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json"); + Tx1559[] memory transactions = readTx1559s(path); + } + + function testReadReceipt() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json"); + uint index = 5; + Receipt memory receipt = readReceipt(path, index); + assertEq(receipt.logsBloom, + hex"00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100"); + } + + function testReadReceipts() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/src/test/fixtures/broadcast.log.json"); + Receipt[] memory receipts = readReceipts(path); + } + +} + +contract Bar { + constructor() { + /// `DEAL` STDCHEAT + totalSupply = 10000e18; + balanceOf[address(this)] = totalSupply; + } + + /// `HOAX` STDCHEATS + function bar(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + } + function origin(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + require(tx.origin == expectedSender, "!prank"); + } + function origin(address expectedSender, address expectedOrigin) public payable { + require(msg.sender == expectedSender, "!prank"); + require(tx.origin == expectedOrigin, "!prank"); + } + + /// `DEAL` STDCHEAT + mapping (address => uint256) public balanceOf; + uint256 public totalSupply; +} + +contract RevertingContract { + constructor() { + revert(); + } +} + diff --git a/lib/forge-std/src/test/StdError.t.sol b/lib/forge-std/src/test/StdError.t.sol new file mode 100644 index 0000000..0d6601e --- /dev/null +++ b/lib/forge-std/src/test/StdError.t.sol @@ -0,0 +1,124 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.10 <0.9.0; + +import "../Test.sol"; + +contract StdErrorsTest is Test { + ErrorsTest test; + + function setUp() public { + test = new ErrorsTest(); + } + + function testExpectAssertion() public { + vm.expectRevert(stdError.assertionError); + test.assertionError(); + } + + function testExpectArithmetic() public { + vm.expectRevert(stdError.arithmeticError); + test.arithmeticError(10); + } + + function testExpectDiv() public { + vm.expectRevert(stdError.divisionError); + test.divError(0); + } + + function testExpectMod() public { + vm.expectRevert(stdError.divisionError); + test.modError(0); + } + + function testExpectEnum() public { + vm.expectRevert(stdError.enumConversionError); + test.enumConversion(1); + } + + function testExpectEncodeStg() public { + vm.expectRevert(stdError.encodeStorageError); + test.encodeStgError(); + } + + function testExpectPop() public { + vm.expectRevert(stdError.popError); + test.pop(); + } + + function testExpectOOB() public { + vm.expectRevert(stdError.indexOOBError); + test.indexOOBError(1); + } + + function testExpectMem() public { + vm.expectRevert(stdError.memOverflowError); + test.mem(); + } + + function testExpectIntern() public { + vm.expectRevert(stdError.zeroVarError); + test.intern(); + } + + function testExpectLowLvl() public { + vm.expectRevert(stdError.lowLevelError); + test.someArr(0); + } +} + +contract ErrorsTest { + enum T { + T1 + } + + uint256[] public someArr; + bytes someBytes; + + function assertionError() public pure { + assert(false); + } + + function arithmeticError(uint256 a) public pure { + a -= 100; + } + + function divError(uint256 a) public pure { + 100 / a; + } + + function modError(uint256 a) public pure { + 100 % a; + } + + function enumConversion(uint256 a) public pure { + T(a); + } + + function encodeStgError() public { + /// @solidity memory-safe-assembly + assembly { + sstore(someBytes.slot, 1) + } + keccak256(someBytes); + } + + function pop() public { + someArr.pop(); + } + + function indexOOBError(uint256 a) public pure { + uint256[] memory t = new uint256[](0); + t[a]; + } + + function mem() public pure { + uint256 l = 2**256 / 32; + new uint256[](l); + } + + function intern() public returns (uint256) { + function(uint256) internal returns (uint256) x; + x(2); + return 7; + } +} diff --git a/lib/forge-std/src/test/StdMath.t.sol b/lib/forge-std/src/test/StdMath.t.sol new file mode 100644 index 0000000..9d09b81 --- /dev/null +++ b/lib/forge-std/src/test/StdMath.t.sol @@ -0,0 +1,200 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.0 <0.9.0; + +import "../Test.sol"; + +contract StdMathTest is Test +{ + function testGetAbs() external { + assertEq(stdMath.abs(-50), 50); + assertEq(stdMath.abs(50), 50); + assertEq(stdMath.abs(-1337), 1337); + assertEq(stdMath.abs(0), 0); + + assertEq(stdMath.abs(type(int256).min), (type(uint256).max >> 1) + 1); + assertEq(stdMath.abs(type(int256).max), (type(uint256).max >> 1)); + } + + function testGetAbs_Fuzz(int256 a) external { + uint256 manualAbs = getAbs(a); + + uint256 abs = stdMath.abs(a); + + assertEq(abs, manualAbs); + } + + function testGetDelta_Uint() external { + assertEq(stdMath.delta(uint256(0), uint256(0)), 0); + assertEq(stdMath.delta(uint256(0), uint256(1337)), 1337); + assertEq(stdMath.delta(uint256(0), type(uint64).max), type(uint64).max); + assertEq(stdMath.delta(uint256(0), type(uint128).max), type(uint128).max); + assertEq(stdMath.delta(uint256(0), type(uint256).max), type(uint256).max); + + assertEq(stdMath.delta(0, uint256(0)), 0); + assertEq(stdMath.delta(1337, uint256(0)), 1337); + assertEq(stdMath.delta(type(uint64).max, uint256(0)), type(uint64).max); + assertEq(stdMath.delta(type(uint128).max, uint256(0)), type(uint128).max); + assertEq(stdMath.delta(type(uint256).max, uint256(0)), type(uint256).max); + + assertEq(stdMath.delta(1337, uint256(1337)), 0); + assertEq(stdMath.delta(type(uint256).max, type(uint256).max), 0); + assertEq(stdMath.delta(5000, uint256(1250)), 3750); + } + + function testGetDelta_Uint_Fuzz(uint256 a, uint256 b) external { + uint256 manualDelta; + if (a > b) { + manualDelta = a - b; + } else { + manualDelta = b - a; + } + + uint256 delta = stdMath.delta(a, b); + + assertEq(delta, manualDelta); + } + + function testGetDelta_Int() external { + assertEq(stdMath.delta(int256(0), int256(0)), 0); + assertEq(stdMath.delta(int256(0), int256(1337)), 1337); + assertEq(stdMath.delta(int256(0), type(int64).max), type(uint64).max >> 1); + assertEq(stdMath.delta(int256(0), type(int128).max), type(uint128).max >> 1); + assertEq(stdMath.delta(int256(0), type(int256).max), type(uint256).max >> 1); + + assertEq(stdMath.delta(0, int256(0)), 0); + assertEq(stdMath.delta(1337, int256(0)), 1337); + assertEq(stdMath.delta(type(int64).max, int256(0)), type(uint64).max >> 1); + assertEq(stdMath.delta(type(int128).max, int256(0)), type(uint128).max >> 1); + assertEq(stdMath.delta(type(int256).max, int256(0)), type(uint256).max >> 1); + + assertEq(stdMath.delta(-0, int256(0)), 0); + assertEq(stdMath.delta(-1337, int256(0)), 1337); + assertEq(stdMath.delta(type(int64).min, int256(0)), (type(uint64).max >> 1) + 1); + assertEq(stdMath.delta(type(int128).min, int256(0)), (type(uint128).max >> 1) + 1); + assertEq(stdMath.delta(type(int256).min, int256(0)), (type(uint256).max >> 1) + 1); + + assertEq(stdMath.delta(int256(0), -0), 0); + assertEq(stdMath.delta(int256(0), -1337), 1337); + assertEq(stdMath.delta(int256(0), type(int64).min), (type(uint64).max >> 1) + 1); + assertEq(stdMath.delta(int256(0), type(int128).min), (type(uint128).max >> 1) + 1); + assertEq(stdMath.delta(int256(0), type(int256).min), (type(uint256).max >> 1) + 1); + + assertEq(stdMath.delta(1337, int256(1337)), 0); + assertEq(stdMath.delta(type(int256).max, type(int256).max), 0); + assertEq(stdMath.delta(type(int256).min, type(int256).min), 0); + assertEq(stdMath.delta(type(int256).min, type(int256).max), type(uint256).max); + assertEq(stdMath.delta(5000, int256(1250)), 3750); + } + + function testGetDelta_Int_Fuzz(int256 a, int256 b) external { + uint256 absA = getAbs(a); + uint256 absB = getAbs(b); + uint256 absDelta = absA > absB + ? absA - absB + : absB - absA; + + uint256 manualDelta; + if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) { + manualDelta = absDelta; + } + // (a < 0 && b >= 0) || (a >= 0 && b < 0) + else { + manualDelta = absA + absB; + } + + uint256 delta = stdMath.delta(a, b); + + assertEq(delta, manualDelta); + } + + function testGetPercentDelta_Uint() external { + assertEq(stdMath.percentDelta(uint256(0), uint256(1337)), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint64).max), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint128).max), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint192).max), 1e18); + + assertEq(stdMath.percentDelta(1337, uint256(1337)), 0); + assertEq(stdMath.percentDelta(type(uint192).max, type(uint192).max), 0); + assertEq(stdMath.percentDelta(0, uint256(2500)), 1e18); + assertEq(stdMath.percentDelta(2500, uint256(2500)), 0); + assertEq(stdMath.percentDelta(5000, uint256(2500)), 1e18); + assertEq(stdMath.percentDelta(7500, uint256(2500)), 2e18); + + vm.expectRevert(stdError.divisionError); + stdMath.percentDelta(uint256(1), 0); + } + + function testGetPercentDelta_Uint_Fuzz(uint192 a, uint192 b) external { + vm.assume(b != 0); + uint256 manualDelta; + if (a > b) { + manualDelta = a - b; + } else { + manualDelta = b - a; + } + + uint256 manualPercentDelta = manualDelta * 1e18 / b; + uint256 percentDelta = stdMath.percentDelta(a, b); + + assertEq(percentDelta, manualPercentDelta); + } + + function testGetPercentDelta_Int() external { + assertEq(stdMath.percentDelta(int256(0), int256(1337)), 1e18); + assertEq(stdMath.percentDelta(int256(0), -1337), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int64).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int128).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int192).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int64).max), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int128).max), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int192).max), 1e18); + + assertEq(stdMath.percentDelta(1337, int256(1337)), 0); + assertEq(stdMath.percentDelta(type(int192).max, type(int192).max), 0); + assertEq(stdMath.percentDelta(type(int192).min, type(int192).min), 0); + + assertEq(stdMath.percentDelta(type(int192).min, type(int192).max), 2e18); // rounds the 1 wei diff down + assertEq(stdMath.percentDelta(type(int192).max, type(int192).min), 2e18 - 1); // rounds the 1 wei diff down + assertEq(stdMath.percentDelta(0, int256(2500)), 1e18); + assertEq(stdMath.percentDelta(2500, int256(2500)), 0); + assertEq(stdMath.percentDelta(5000, int256(2500)), 1e18); + assertEq(stdMath.percentDelta(7500, int256(2500)), 2e18); + + vm.expectRevert(stdError.divisionError); + stdMath.percentDelta(int256(1), 0); + } + + function testGetPercentDelta_Int_Fuzz(int192 a, int192 b) external { + vm.assume(b != 0); + uint256 absA = getAbs(a); + uint256 absB = getAbs(b); + uint256 absDelta = absA > absB + ? absA - absB + : absB - absA; + + uint256 manualDelta; + if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) { + manualDelta = absDelta; + } + // (a < 0 && b >= 0) || (a >= 0 && b < 0) + else { + manualDelta = absA + absB; + } + + uint256 manualPercentDelta = manualDelta * 1e18 / absB; + uint256 percentDelta = stdMath.percentDelta(a, b); + + assertEq(percentDelta, manualPercentDelta); + } + + /*////////////////////////////////////////////////////////////////////////// + HELPERS + //////////////////////////////////////////////////////////////////////////*/ + + function getAbs(int256 a) private pure returns (uint256) { + if (a < 0) + return a == type(int256).min ? uint256(type(int256).max) + 1 : uint256(-a); + + return uint256(a); + } +} diff --git a/lib/forge-std/src/test/StdStorage.t.sol b/lib/forge-std/src/test/StdStorage.t.sol new file mode 100644 index 0000000..6e238d0 --- /dev/null +++ b/lib/forge-std/src/test/StdStorage.t.sol @@ -0,0 +1,321 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../Test.sol"; + +contract StdStorageTest is Test { + using stdStorage for StdStorage; + + StorageTest test; + + function setUp() public { + test = new StorageTest(); + } + + function testStorageHidden() public { + assertEq(uint256(keccak256("my.random.var")), stdstore.target(address(test)).sig("hidden()").find()); + } + + function testStorageObvious() public { + assertEq(uint256(0), stdstore.target(address(test)).sig("exists()").find()); + } + + function testStorageCheckedWriteHidden() public { + stdstore.target(address(test)).sig(test.hidden.selector).checked_write(100); + assertEq(uint256(test.hidden()), 100); + } + + function testStorageCheckedWriteObvious() public { + stdstore.target(address(test)).sig(test.exists.selector).checked_write(100); + assertEq(test.exists(), 100); + } + + function testStorageMapStructA() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.map_struct.selector) + .with_key(address(this)) + .depth(0) + .find(); + assertEq(uint256(keccak256(abi.encode(address(this), 4))), slot); + } + + function testStorageMapStructB() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.map_struct.selector) + .with_key(address(this)) + .depth(1) + .find(); + assertEq(uint256(keccak256(abi.encode(address(this), 4))) + 1, slot); + } + + function testStorageDeepMap() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.deep_map.selector) + .with_key(address(this)) + .with_key(address(this)) + .find(); + assertEq(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint(5)))))), slot); + } + + function testStorageCheckedWriteDeepMap() public { + stdstore + .target(address(test)) + .sig(test.deep_map.selector) + .with_key(address(this)) + .with_key(address(this)) + .checked_write(100); + assertEq(100, test.deep_map(address(this), address(this))); + } + + function testStorageDeepMapStructA() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.deep_map_struct.selector) + .with_key(address(this)) + .with_key(address(this)) + .depth(0) + .find(); + assertEq(bytes32(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint(6)))))) + 0), bytes32(slot)); + } + + function testStorageDeepMapStructB() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.deep_map_struct.selector) + .with_key(address(this)) + .with_key(address(this)) + .depth(1) + .find(); + assertEq(bytes32(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint(6)))))) + 1), bytes32(slot)); + } + + function testStorageCheckedWriteDeepMapStructA() public { + stdstore + .target(address(test)) + .sig(test.deep_map_struct.selector) + .with_key(address(this)) + .with_key(address(this)) + .depth(0) + .checked_write(100); + (uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this)); + assertEq(100, a); + assertEq(0, b); + } + + function testStorageCheckedWriteDeepMapStructB() public { + stdstore + .target(address(test)) + .sig(test.deep_map_struct.selector) + .with_key(address(this)) + .with_key(address(this)) + .depth(1) + .checked_write(100); + (uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this)); + assertEq(0, a); + assertEq(100, b); + } + + function testStorageCheckedWriteMapStructA() public { + stdstore + .target(address(test)) + .sig(test.map_struct.selector) + .with_key(address(this)) + .depth(0) + .checked_write(100); + (uint256 a, uint256 b) = test.map_struct(address(this)); + assertEq(a, 100); + assertEq(b, 0); + } + + function testStorageCheckedWriteMapStructB() public { + stdstore + .target(address(test)) + .sig(test.map_struct.selector) + .with_key(address(this)) + .depth(1) + .checked_write(100); + (uint256 a, uint256 b) = test.map_struct(address(this)); + assertEq(a, 0); + assertEq(b, 100); + } + + function testStorageStructA() public { + uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(0).find(); + assertEq(uint256(7), slot); + } + + function testStorageStructB() public { + uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(1).find(); + assertEq(uint256(7) + 1, slot); + } + + function testStorageCheckedWriteStructA() public { + stdstore.target(address(test)).sig(test.basic.selector).depth(0).checked_write(100); + (uint256 a, uint256 b) = test.basic(); + assertEq(a, 100); + assertEq(b, 1337); + } + + function testStorageCheckedWriteStructB() public { + stdstore.target(address(test)).sig(test.basic.selector).depth(1).checked_write(100); + (uint256 a, uint256 b) = test.basic(); + assertEq(a, 1337); + assertEq(b, 100); + } + + function testStorageMapAddrFound() public { + uint256 slot = stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).find(); + assertEq(uint256(keccak256(abi.encode(address(this), uint(1)))), slot); + } + + function testStorageMapUintFound() public { + uint256 slot = stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).find(); + assertEq(uint256(keccak256(abi.encode(100, uint(2)))), slot); + } + + function testStorageCheckedWriteMapUint() public { + stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).checked_write(100); + assertEq(100, test.map_uint(100)); + } + + function testStorageCheckedWriteMapAddr() public { + stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).checked_write(100); + assertEq(100, test.map_addr(address(this))); + } + + function testStorageCheckedWriteMapBool() public { + stdstore.target(address(test)).sig(test.map_bool.selector).with_key(address(this)).checked_write(true); + assertTrue(test.map_bool(address(this))); + } + + function testFailStorageCheckedWriteMapPacked() public { + // expect PackedSlot error but not external call so cant expectRevert + stdstore.target(address(test)).sig(test.read_struct_lower.selector).with_key(address(uint160(1337))).checked_write(100); + } + + function testStorageCheckedWriteMapPackedSuccess() public { + uint256 full = test.map_packed(address(1337)); + // keep upper 128, set lower 128 to 1337 + full = (full & (uint256((1 << 128) - 1) << 128)) | 1337; + stdstore.target(address(test)).sig(test.map_packed.selector).with_key(address(uint160(1337))).checked_write(full); + assertEq(1337, test.read_struct_lower(address(1337))); + } + + function testFailStorageConst() public { + // vm.expectRevert(abi.encodeWithSignature("NotStorage(bytes4)", bytes4(keccak256("const()")))); + stdstore.target(address(test)).sig("const()").find(); + } + + function testFailStorageNativePack() public { + stdstore.target(address(test)).sig(test.tA.selector).find(); + stdstore.target(address(test)).sig(test.tB.selector).find(); + + // these both would fail + stdstore.target(address(test)).sig(test.tC.selector).find(); + stdstore.target(address(test)).sig(test.tD.selector).find(); + } + + function testStorageReadBytes32() public { + bytes32 val = stdstore.target(address(test)).sig(test.tE.selector).read_bytes32(); + assertEq(val, hex"1337"); + } + + function testStorageReadBool_False() public { + bool val = stdstore.target(address(test)).sig(test.tB.selector).read_bool(); + assertEq(val, false); + } + + function testStorageReadBool_True() public { + bool val = stdstore.target(address(test)).sig(test.tH.selector).read_bool(); + assertEq(val, true); + } + + function testStorageReadBool_Revert() public { + vm.expectRevert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool."); + this.readNonBoolValue(); + } + + function readNonBoolValue() public { + stdstore.target(address(test)).sig(test.tE.selector).read_bool(); + } + + function testStorageReadAddress() public { + address val = stdstore.target(address(test)).sig(test.tF.selector).read_address(); + assertEq(val, address(1337)); + } + + function testStorageReadUint() public { + uint256 val = stdstore.target(address(test)).sig(test.exists.selector).read_uint(); + assertEq(val, 1); + } + + function testStorageReadInt() public { + int256 val = stdstore.target(address(test)).sig(test.tG.selector).read_int(); + assertEq(val, type(int256).min); + } +} + +contract StorageTest { + uint256 public exists = 1; + mapping(address => uint256) public map_addr; + mapping(uint256 => uint256) public map_uint; + mapping(address => uint256) public map_packed; + mapping(address => UnpackedStruct) public map_struct; + mapping(address => mapping(address => uint256)) public deep_map; + mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct; + UnpackedStruct public basic; + + uint248 public tA; + bool public tB; + + + bool public tC = false; + uint248 public tD = 1; + + + struct UnpackedStruct { + uint256 a; + uint256 b; + } + + mapping(address => bool) public map_bool; + + bytes32 public tE = hex"1337"; + address public tF = address(1337); + int256 public tG = type(int256).min; + bool public tH = true; + + constructor() { + basic = UnpackedStruct({ + a: 1337, + b: 1337 + }); + + uint256 two = (1<<128) | 1; + map_packed[msg.sender] = two; + map_packed[address(bytes20(uint160(1337)))] = 1<<128; + } + + function read_struct_upper(address who) public view returns (uint256) { + return map_packed[who] >> 128; + } + + function read_struct_lower(address who) public view returns (uint256) { + return map_packed[who] & ((1 << 128) - 1); + } + + function hidden() public view returns (bytes32 t) { + bytes32 slot = keccak256("my.random.var"); + /// @solidity memory-safe-assembly + assembly { + t := sload(slot) + } + } + + function const() public pure returns (bytes32 t) { + t = bytes32(hex"1337"); + } +} diff --git a/lib/forge-std/src/test/fixtures/broadcast.log.json b/lib/forge-std/src/test/fixtures/broadcast.log.json new file mode 100644 index 0000000..0a0200b --- /dev/null +++ b/lib/forge-std/src/test/fixtures/broadcast.log.json @@ -0,0 +1,187 @@ +{ + "transactions": [ + { + "hash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "function": "multiple_arguments(uint256,address,uint256[]):(uint256)", + "arguments": ["1", "0000000000000000000000000000000000001337", "[3,4]"], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "gas": "0x73b9", + "value": "0x0", + "data": "0x23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004", + "nonce": "0x3", + "accessList": [] + } + }, + { + "hash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "function": "inc():(uint256)", + "arguments": [], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "gas": "0xdcb2", + "value": "0x0", + "data": "0x371303c0", + "nonce": "0x4", + "accessList": [] + } + }, + { + "hash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "function": "t(uint256):(uint256)", + "arguments": ["1"], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "gas": "0x8599", + "value": "0x0", + "data": "0xafe29f710000000000000000000000000000000000000000000000000000000000000001", + "nonce": "0x5", + "accessList": [] + } + } + ], + "receipts": [ + { + "transactionHash": "0x481dc86e40bba90403c76f8e144aa9ff04c1da2164299d0298573835f0991181", + "transactionIndex": "0x0", + "blockHash": "0xef0730448490304e5403be0fa8f8ce64f118e9adcca60c07a2ae1ab921d748af", + "blockNumber": "0x1", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": null, + "cumulativeGasUsed": "0x13f3a", + "gasUsed": "0x13f3a", + "contractAddress": "0x5fbdb2315678afecb367f032d93f642f64180aa3", + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x6a187183545b8a9e7f1790e847139379bf5622baff2cb43acf3f5c79470af782", + "transactionIndex": "0x0", + "blockHash": "0xf3acb96a90071640c2a8c067ae4e16aad87e634ea8d8bbbb5b352fba86ba0148", + "blockNumber": "0x2", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": null, + "cumulativeGasUsed": "0x45d80", + "gasUsed": "0x45d80", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x064ad173b4867bdef2fb60060bbdaf01735fbf10414541ea857772974e74ea9d", + "transactionIndex": "0x0", + "blockHash": "0x8373d02109d3ee06a0225f23da4c161c656ccc48fe0fcee931d325508ae73e58", + "blockNumber": "0x3", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", + "cumulativeGasUsed": "0x45feb", + "gasUsed": "0x45feb", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f", + "transactionIndex": "0x0", + "blockHash": "0x16712fae5c0e18f75045f84363fb6b4d9a9fe25e660c4ce286833a533c97f629", + "blockNumber": "0x4", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "cumulativeGasUsed": "0x5905", + "gasUsed": "0x5905", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298", + "transactionIndex": "0x0", + "blockHash": "0x156b88c3eb9a1244ba00a1834f3f70de735b39e3e59006dd03af4fe7d5480c11", + "blockNumber": "0x5", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "cumulativeGasUsed": "0xa9c4", + "gasUsed": "0xa9c4", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "transactionIndex": "0x0", + "blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb", + "blockNumber": "0x6", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "cumulativeGasUsed": "0x66c5", + "gasUsed": "0x66c5", + "contractAddress": null, + "logs": [ + { + "address": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "topics": [ + "0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000046865726500000000000000000000000000000000000000000000000000000000", + "blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb", + "blockNumber": "0x6", + "transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "transactionIndex": "0x1", + "logIndex": "0x0", + "transactionLogIndex": "0x0", + "removed": false + } + ], + "status": "0x1", + "logsBloom": "0x00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x11fbb10230c168ca1e36a7e5c69a6dbcd04fd9e64ede39d10a83e36ee8065c16", + "transactionIndex": "0x0", + "blockHash": "0xf1e0ed2eda4e923626ec74621006ed50b3fc27580dc7b4cf68a07ca77420e29c", + "blockNumber": "0x7", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x0000000000000000000000000000000000001337", + "cumulativeGasUsed": "0x5208", + "gasUsed": "0x5208", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + } + ], + "libraries": [ + "src/Broadcast.t.sol:F:0x5fbdb2315678afecb367f032d93f642f64180aa3" + ], + "pending": [], + "path": "broadcast/Broadcast.t.sol/31337/run-latest.json", + "returns": {}, + "timestamp": 1655140035 +} diff --git a/package-lock.json b/package-lock.json index 53b5579..46dd870 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,11 +1,11 @@ { - "name": "lens-protocol", + "name": "@aave/lens-protocol", "version": "1.0.2", "lockfileVersion": 2, "requires": true, "packages": { "": { - "name": "lens-protocol", + "name": "@aave/lens-protocol", "version": "1.0.2", "license": "MIT", "dependencies": { @@ -28,16 +28,17 @@ "eslint-config-prettier": "8.3.0", "eslint-plugin-prettier": "4.0.0", "ethereum-waffle": "3.4.0", - "ethers": "5.5.1", - "hardhat": "2.7.0", + "ethers": "^5.7.1", + "hardhat": "^2.12.0", "hardhat-contract-sizer": "2.1.1", "hardhat-gas-reporter": "1.0.6", "hardhat-log-remover": "2.0.2", "hardhat-spdx-license-identifier": "2.0.3", + "hardhat-tracer": "^1.1.0-rc.6", "husky": "7.0.4", "prettier": "2.5.0", "prettier-plugin-solidity": "1.0.0-beta.19", - "solidity-coverage": "0.7.17", + "solidity-coverage": "^0.8.2", "ts-generator": "0.1.1", "ts-node": "10.4.0", "typechain": "6.0.5", @@ -277,22 +278,6 @@ "dev": true, "license": "Python-2.0" }, - "node_modules/@eslint/eslintrc/node_modules/debug": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, "node_modules/@eslint/eslintrc/node_modules/ignore": { "version": "4.0.6", "dev": true, @@ -471,84 +456,11 @@ "node": ">=10.0" } }, - "node_modules/@ethereumjs/block": { - "version": "3.6.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/tx": "^3.4.0", - "ethereumjs-util": "^7.1.3", - "merkle-patricia-tree": "^4.2.2" - } - }, - "node_modules/@ethereumjs/block/node_modules/@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "license": "MIT", - "dependencies": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "node_modules/@ethereumjs/block/node_modules/@ethereumjs/tx": { - "version": "3.4.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/common": "^2.6.0", - "ethereumjs-util": "^7.1.3" - } - }, - "node_modules/@ethereumjs/blockchain": { - "version": "5.5.1", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/block": "^3.6.0", - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/ethash": "^1.1.0", - "debug": "^2.2.0", - "ethereumjs-util": "^7.1.3", - "level-mem": "^5.0.1", - "lru-cache": "^5.1.1", - "semaphore-async-await": "^1.5.1" - } - }, - "node_modules/@ethereumjs/blockchain/node_modules/@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "license": "MIT", - "dependencies": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "node_modules/@ethereumjs/blockchain/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/@ethereumjs/blockchain/node_modules/lru-cache": { - "version": "5.1.1", - "dev": true, - "license": "ISC", - "dependencies": { - "yallist": "^3.0.2" - } - }, - "node_modules/@ethereumjs/blockchain/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, "node_modules/@ethereumjs/common": { "version": "2.4.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "crc-32": "^1.2.0", "ethereumjs-util": "^7.1.0" @@ -558,6 +470,7 @@ "version": "5.1.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@types/node": "*" } @@ -565,12 +478,14 @@ "node_modules/@ethereumjs/common/node_modules/bn.js": { "version": "5.2.0", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/@ethereumjs/common/node_modules/ethereumjs-util": { "version": "7.1.0", "dev": true, "license": "MPL-2.0", + "peer": true, "dependencies": { "@types/bn.js": "^5.1.0", "bn.js": "^5.1.2", @@ -583,116 +498,10 @@ "node": ">=10.0.0" } }, - "node_modules/@ethereumjs/ethash": { - "version": "1.1.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/block": "^3.5.0", - "@types/levelup": "^4.3.0", - "buffer-xor": "^2.0.1", - "ethereumjs-util": "^7.1.1", - "miller-rabin": "^4.0.0" - } - }, - "node_modules/@ethereumjs/ethash/node_modules/buffer-xor": { - "version": "2.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "safe-buffer": "^5.1.1" - } - }, - "node_modules/@ethereumjs/tx": { - "version": "3.3.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/common": "^2.4.0", - "ethereumjs-util": "^7.1.0" - } - }, - "node_modules/@ethereumjs/tx/node_modules/@types/bn.js": { - "version": "5.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/@ethereumjs/tx/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, - "node_modules/@ethereumjs/tx/node_modules/ethereumjs-util": { - "version": "7.1.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@types/bn.js": "^5.1.0", - "bn.js": "^5.1.2", - "create-hash": "^1.1.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "0.1.6", - "rlp": "^2.2.4" - }, - "engines": { - "node": ">=10.0.0" - } - }, - "node_modules/@ethereumjs/vm": { - "version": "5.6.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/block": "^3.6.0", - "@ethereumjs/blockchain": "^5.5.0", - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/tx": "^3.4.0", - "async-eventemitter": "^0.2.4", - "core-js-pure": "^3.0.1", - "debug": "^2.2.0", - "ethereumjs-util": "^7.1.3", - "functional-red-black-tree": "^1.0.1", - "mcl-wasm": "^0.7.1", - "merkle-patricia-tree": "^4.2.2", - "rustbn.js": "~0.2.0" - } - }, - "node_modules/@ethereumjs/vm/node_modules/@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "license": "MIT", - "dependencies": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "node_modules/@ethereumjs/vm/node_modules/@ethereumjs/tx": { - "version": "3.4.0", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@ethereumjs/common": "^2.6.0", - "ethereumjs-util": "^7.1.3" - } - }, - "node_modules/@ethereumjs/vm/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/@ethereumjs/vm/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, "node_modules/@ethersproject/abi": { - "version": "5.3.1", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz", + "integrity": "sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==", "dev": true, "funding": [ { @@ -704,21 +513,22 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/address": "^5.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/hash": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.3.0", + "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": [ { @@ -730,19 +540,20 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/networks": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/transactions": "^5.3.0", - "@ethersproject/web": "^5.3.0" + "@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.3.0", + "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": [ { @@ -754,17 +565,18 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-provider": "^5.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0" + "@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.3.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz", + "integrity": "sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==", "dev": true, "funding": [ { @@ -776,17 +588,18 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/rlp": "^5.3.0" + "@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.3.0", + "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": [ { @@ -798,13 +611,14 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.3.0" + "@ethersproject/bytes": "^5.7.0" } }, "node_modules/@ethersproject/basex": { - "version": "5.5.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz", + "integrity": "sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==", "dev": true, "funding": [ { @@ -816,65 +630,15 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/basex/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/basex/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/basex/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" } }, "node_modules/@ethersproject/bignumber": { - "version": "5.3.0", + "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": [ { @@ -886,15 +650,22 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "bn.js": "^4.11.9" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" } }, + "node_modules/@ethersproject/bignumber/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/@ethersproject/bytes": { - "version": "5.3.0", + "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": [ { @@ -906,13 +677,14 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/logger": "^5.3.0" + "@ethersproject/logger": "^5.7.0" } }, "node_modules/@ethersproject/constants": { - "version": "5.3.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz", + "integrity": "sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==", "dev": true, "funding": [ { @@ -924,13 +696,14 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.3.0" + "@ethersproject/bignumber": "^5.7.0" } }, "node_modules/@ethersproject/contracts": { - "version": "5.5.0", + "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": [ { @@ -942,395 +715,23 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abi": "^5.5.0", - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/abi": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/hash": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/contracts/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" + "@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.3.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz", + "integrity": "sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==", "dev": true, "funding": [ { @@ -1342,20 +743,22 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-signer": "^5.3.0", - "@ethersproject/address": "^5.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.5.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz", + "integrity": "sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==", "dev": true, "funding": [ { @@ -1367,346 +770,25 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/basex": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/pbkdf2": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/wordlists": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/hdnode/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" + "@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.5.0", + "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": [ { @@ -1718,25 +800,26 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/hdnode": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/pbkdf2": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", + "@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/json-wallets/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.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": [ { @@ -1748,341 +831,15 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", + "@ethersproject/bytes": "^5.7.0", "js-sha3": "0.8.0" } }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/json-wallets/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/keccak256": { - "version": "5.3.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.3.0", - "js-sha3": "0.5.7" - } - }, - "node_modules/@ethersproject/keccak256/node_modules/js-sha3": { - "version": "0.5.7", - "dev": true, - "license": "MIT" - }, "node_modules/@ethersproject/logger": { - "version": "5.3.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz", + "integrity": "sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==", "dev": true, "funding": [ { @@ -2093,11 +850,12 @@ "type": "individual", "url": "https://www.buymeacoffee.com/ricmoo" } - ], - "license": "MIT" + ] }, "node_modules/@ethersproject/networks": { - "version": "5.3.1", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz", + "integrity": "sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==", "dev": true, "funding": [ { @@ -2109,13 +867,14 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/logger": "^5.3.0" + "@ethersproject/logger": "^5.7.0" } }, "node_modules/@ethersproject/pbkdf2": { - "version": "5.5.0", + "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": [ { @@ -2127,47 +886,15 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/sha2": "^5.5.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" } }, - "node_modules/@ethersproject/pbkdf2/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/pbkdf2/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, "node_modules/@ethersproject/properties": { - "version": "5.3.0", + "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": [ { @@ -2179,13 +906,14 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/logger": "^5.3.0" + "@ethersproject/logger": "^5.7.0" } }, "node_modules/@ethersproject/providers": { - "version": "5.5.0", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.1.tgz", + "integrity": "sha512-vZveG/DLyo+wk4Ga1yx6jSEHrLPgmTt+dFv0dv8URpVCRf0jVhalps1jq/emN/oXnMRsC7cQgAF32DcXLL7BPQ==", "dev": true, "funding": [ { @@ -2197,378 +925,33 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/basex": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.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/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/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/hash": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/providers/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, "node_modules/@ethersproject/random": { - "version": "5.5.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz", + "integrity": "sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==", "dev": true, "funding": [ { @@ -2580,47 +963,15 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, - "node_modules/@ethersproject/random/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/random/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, "node_modules/@ethersproject/rlp": { - "version": "5.3.0", + "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": [ { @@ -2632,14 +983,15 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "node_modules/@ethersproject/sha2": { - "version": "5.5.0", + "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": [ { @@ -2651,48 +1003,16 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", "hash.js": "1.1.7" } }, - "node_modules/@ethersproject/sha2/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/sha2/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, "node_modules/@ethersproject/signing-key": { - "version": "5.3.0", + "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": [ { @@ -2704,18 +1024,25 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "bn.js": "^4.11.9", + "@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/signing-key/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/@ethersproject/solidity": { - "version": "5.5.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz", + "integrity": "sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==", "dev": true, "funding": [ { @@ -2727,128 +1054,19 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/solidity/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" + "@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.3.0", + "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": [ { @@ -2860,15 +1078,16 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/logger": "^5.3.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "node_modules/@ethersproject/transactions": { - "version": "5.3.0", + "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": [ { @@ -2880,21 +1099,22 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/address": "^5.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/rlp": "^5.3.0", - "@ethersproject/signing-key": "^5.3.0" + "@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.5.0", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz", + "integrity": "sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==", "dev": true, "funding": [ { @@ -2906,86 +1126,16 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, - "node_modules/@ethersproject/units/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/units/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/units/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/units/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, "node_modules/@ethersproject/wallet": { - "version": "5.5.0", + "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": [ { @@ -2997,374 +1147,28 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/hdnode": "^5.5.0", - "@ethersproject/json-wallets": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/wordlists": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/hash": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/wallet/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.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/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.3.0", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz", + "integrity": "sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==", "dev": true, "funding": [ { @@ -3376,17 +1180,18 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/base64": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.5.0", + "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": [ { @@ -3398,360 +1203,12 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/hash": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/@ethersproject/wordlists/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" + "@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/@humanwhocodes/config-array": { @@ -3772,6 +1229,46 @@ "dev": true, "license": "BSD-3-Clause" }, + "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/@noble/hashes": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.2.tgz", + "integrity": "sha512-KYRCASVTv6aeUi1tsF8/vpyR7zpfs3FUzy2Jqm+MU+LmUKhQ0y2FpfwqkCcxSg2ua4GALJd8k2R76WxwZGbQpA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ] + }, + "node_modules/@noble/secp256k1": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.6.3.tgz", + "integrity": "sha512-T04e4iTurVy7I8Sw4+c5OSN9/RkPlo1uKxAomtxQNLq8j1uPAqnsqG1bqvY3Jv7c13gyr6dui0zmh/I3+f/JaQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ] + }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.4", "dev": true, @@ -3804,6 +1301,379 @@ "node": ">= 8" } }, + "node_modules/@nomicfoundation/ethereumjs-block": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-4.0.0.tgz", + "integrity": "sha512-bk8uP8VuexLgyIZAHExH1QEovqx0Lzhc9Ntm63nCRKLHXIZkobaFaeCVwTESV7YkPKUk7NiK11s8ryed4CS9yA==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-blockchain": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-6.0.0.tgz", + "integrity": "sha512-pLFEoea6MWd81QQYSReLlLfH7N9v7lH66JC/NMPN848ySPPQA5renWnE7wPByfQFzNrPBuDDRFFULMDmj1C0xw==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-ethash": "^2.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "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/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/@nomicfoundation/ethereumjs-common": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-3.0.0.tgz", + "integrity": "sha512-WS7qSshQfxoZOpHG/XqlHEGRG1zmyjYrvmATvc4c62+gZXgre1ymYP8ZNgx/3FyZY0TWe9OjFlKOfLqmgOeYwA==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "crc-32": "^1.2.0" + } + }, + "node_modules/@nomicfoundation/ethereumjs-ethash": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-2.0.0.tgz", + "integrity": "sha512-WpDvnRncfDUuXdsAXlI4lXbqUDOA+adYRQaEezIkxqDkc+LDyYDbd/xairmY98GnQzo1zIqsIL6GB5MoMSJDew==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "abstract-level": "^1.0.3", + "bigint-crypto-utils": "^3.0.23", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-evm": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-1.0.0.tgz", + "integrity": "sha512-hVS6qRo3V1PLKCO210UfcEQHvlG7GqR8iFzp0yyjTg2TmJQizcChKgWo8KFsdMw6AyoLgLhHGHw4HdlP8a4i+Q==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@types/async-eventemitter": "^0.2.1", + "async-eventemitter": "^0.2.4", + "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-rlp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-4.0.0.tgz", + "integrity": "sha512-GaSOGk5QbUk4eBP5qFbpXoZoZUj/NrW7MRa0tKY4Ew4c2HAS0GXArEMAamtFrkazp0BO4K5p2ZCG3b2FmbShmw==", + "dev": true, + "bin": { + "rlp": "bin/rlp" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-statemanager": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-1.0.0.tgz", + "integrity": "sha512-jCtqFjcd2QejtuAMjQzbil/4NHf5aAWxUc+CvS0JclQpl+7M0bxMofR2AJdtz+P3u0ke2euhYREDiE7iSO31vQ==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "functional-red-black-tree": "^1.0.1" + } + }, + "node_modules/@nomicfoundation/ethereumjs-trie": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-5.0.0.tgz", + "integrity": "sha512-LIj5XdE+s+t6WSuq/ttegJzZ1vliwg6wlb+Y9f4RlBpuK35B9K02bO7xU+E6Rgg9RGptkWd6TVLdedTI4eNc2A==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-tx": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-4.0.0.tgz", + "integrity": "sha512-Gg3Lir2lNUck43Kp/3x6TfBNwcWC9Z1wYue9Nz3v4xjdcv6oDW9QSMJxqsKw9QEGoBBZ+gqwpW7+F05/rs/g1w==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-util": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-8.0.0.tgz", + "integrity": "sha512-2emi0NJ/HmTG+CGY58fa+DQuAoroFeSH9gKu9O6JnwTtlzJtgfTixuoOqLEgyyzZVvwfIpRueuePb8TonL1y+A==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-rlp": "^4.0.0-beta.2", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-vm": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-6.0.0.tgz", + "integrity": "sha512-JMPxvPQ3fzD063Sg3Tp+UdwUkVxMoo1uML6KSzFhMH3hoQi/LMuXBoEHAoW83/vyNS9BxEe6jm6LmT5xdeEJ6w==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-blockchain": "^6.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-evm": "^1.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-statemanager": "^1.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@types/async-eventemitter": "^0.2.1", + "async-eventemitter": "^0.2.4", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "functional-red-black-tree": "^1.0.1", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer/-/solidity-analyzer-0.1.0.tgz", + "integrity": "sha512-xGWAiVCGOycvGiP/qrlf9f9eOn7fpNbyJygcB0P21a1MDuVPlKt0Srp7rvtBEutYQ48ouYnRXm33zlRnlTOPHg==", + "dev": true, + "engines": { + "node": ">= 12" + }, + "optionalDependencies": { + "@nomicfoundation/solidity-analyzer-darwin-arm64": "0.1.0", + "@nomicfoundation/solidity-analyzer-darwin-x64": "0.1.0", + "@nomicfoundation/solidity-analyzer-freebsd-x64": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-x64-musl": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": "0.1.0" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-darwin-arm64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-arm64/-/solidity-analyzer-darwin-arm64-0.1.0.tgz", + "integrity": "sha512-vEF3yKuuzfMHsZecHQcnkUrqm8mnTWfJeEVFHpg+cO+le96xQA4lAJYdUan8pXZohQxv1fSReQsn4QGNuBNuCw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-darwin-x64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-x64/-/solidity-analyzer-darwin-x64-0.1.0.tgz", + "integrity": "sha512-dlHeIg0pTL4dB1l9JDwbi/JG6dHQaU1xpDK+ugYO8eJ1kxx9Dh2isEUtA4d02cQAl22cjOHTvifAk96A+ItEHA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-freebsd-x64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-freebsd-x64/-/solidity-analyzer-freebsd-x64-0.1.0.tgz", + "integrity": "sha512-WFCZYMv86WowDA4GiJKnebMQRt3kCcFqHeIomW6NMyqiKqhK1kIZCxSLDYsxqlx396kKLPN1713Q1S8tu68GKg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-arm64-gnu": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-gnu/-/solidity-analyzer-linux-arm64-gnu-0.1.0.tgz", + "integrity": "sha512-DTw6MNQWWlCgc71Pq7CEhEqkb7fZnS7oly13pujs4cMH1sR0JzNk90Mp1zpSCsCs4oKan2ClhMlLKtNat/XRKQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-arm64-musl": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-musl/-/solidity-analyzer-linux-arm64-musl-0.1.0.tgz", + "integrity": "sha512-wUpUnR/3GV5Da88MhrxXh/lhb9kxh9V3Jya2NpBEhKDIRCDmtXMSqPMXHZmOR9DfCwCvG6vLFPr/+YrPCnUN0w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-x64-gnu": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-gnu/-/solidity-analyzer-linux-x64-gnu-0.1.0.tgz", + "integrity": "sha512-lR0AxK1x/MeKQ/3Pt923kPvwigmGX3OxeU5qNtQ9pj9iucgk4PzhbS3ruUeSpYhUxG50jN4RkIGwUMoev5lguw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-x64-musl": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-musl/-/solidity-analyzer-linux-x64-musl-0.1.0.tgz", + "integrity": "sha512-A1he/8gy/JeBD3FKvmI6WUJrGrI5uWJNr5Xb9WdV+DK0F8msuOqpEByLlnTdLkXMwW7nSl3awvLezOs9xBHJEg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-arm64-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-arm64-msvc/-/solidity-analyzer-win32-arm64-msvc-0.1.0.tgz", + "integrity": "sha512-7x5SXZ9R9H4SluJZZP8XPN+ju7Mx+XeUMWZw7ZAqkdhP5mK19I4vz3x0zIWygmfE8RT7uQ5xMap0/9NPsO+ykw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-ia32-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-ia32-msvc/-/solidity-analyzer-win32-ia32-msvc-0.1.0.tgz", + "integrity": "sha512-m7w3xf+hnE774YRXu+2mGV7RiF3QJtUoiYU61FascCkQhX3QMQavh7saH/vzb2jN5D24nT/jwvaHYX/MAM9zUw==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-x64-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-x64-msvc/-/solidity-analyzer-win32-x64-msvc-0.1.0.tgz", + "integrity": "sha512-xCuybjY0sLJQnJhupiFAXaek2EqF0AP0eBjgzaalPXSNvCEN6ZYHvUzdA50ENDVeSYFXcUsYf3+FsD3XKaeptA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, "node_modules/@nomiclabs/hardhat-ethers": { "version": "2.0.2", "dev": true, @@ -3916,6 +1786,51 @@ "ms": "^2.1.1" } }, + "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.0", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.0.tgz", + "integrity": "sha512-ftTW3kKX54YXLCxH6BB7oEEoJfoE2pIgw7MINKAs5PsS6nqKPuKk1haTF/EuHmYqG330t5GSrdmtRuHaY1a62Q==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "@noble/hashes": "~1.1.1", + "@noble/secp256k1": "~1.6.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@scure/bip39": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.0.tgz", + "integrity": "sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "@noble/hashes": "~1.1.1", + "@scure/base": "~1.1.0" + } + }, "node_modules/@sentry/core": { "version": "5.30.0", "dev": true, @@ -4011,112 +1926,15 @@ "node": ">=6" } }, - "node_modules/@sindresorhus/is": { - "version": "0.14.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, "node_modules/@solidity-parser/parser": { - "version": "0.14.0", + "version": "0.14.3", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.3.tgz", + "integrity": "sha512-29g2SZ29HtsqA58pLCtopI1P/cPy5/UAzlcAXO6T/CNJimG6yA8kx4NaseMyJULiC+TEs02Y9/yeHzClqoA0hw==", "dev": true, - "license": "MIT", "dependencies": { "antlr4ts": "^0.5.0-alpha.4" } }, - "node_modules/@szmarczak/http-timer": { - "version": "1.1.2", - "dev": true, - "license": "MIT", - "dependencies": { - "defer-to-connect": "^1.0.1" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/@truffle/error": { - "version": "0.0.14", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter": { - "version": "0.5.7", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^5.1.3", - "ethers": "^4.0.32", - "web3": "1.5.3" - } - }, - "node_modules/@truffle/interface-adapter/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter/node_modules/ethers": { - "version": "4.0.49", - "dev": true, - "license": "MIT", - "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/@truffle/interface-adapter/node_modules/ethers/node_modules/bn.js": { - "version": "4.12.0", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter/node_modules/hash.js": { - "version": "1.1.3", - "dev": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "minimalistic-assert": "^1.0.0" - } - }, - "node_modules/@truffle/interface-adapter/node_modules/js-sha3": { - "version": "0.5.7", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter/node_modules/scrypt-js": { - "version": "2.0.4", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter/node_modules/setimmediate": { - "version": "1.0.4", - "dev": true, - "license": "MIT" - }, - "node_modules/@truffle/interface-adapter/node_modules/uuid": { - "version": "2.0.1", - "dev": true - }, - "node_modules/@truffle/provider": { - "version": "0.2.41", - "dev": true, - "license": "MIT", - "dependencies": { - "@truffle/error": "^0.0.14", - "@truffle/interface-adapter": "^0.5.7", - "web3": "1.5.3" - } - }, "node_modules/@tsconfig/node10": { "version": "1.0.8", "dev": true, @@ -4208,10 +2026,11 @@ "node": ">= 10.0.0" } }, - "node_modules/@types/abstract-leveldown": { - "version": "5.0.2", - "dev": true, - "license": "MIT" + "node_modules/@types/async-eventemitter": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@types/async-eventemitter/-/async-eventemitter-0.2.1.tgz", + "integrity": "sha512-M2P4Ng26QbAeITiH7w1d7OxtldgfAe0wobpyJzVK/XOb0cUGKU2R4pfAhqcJBXAe2ife5ZOhSv4wk7p+ffURtg==", + "dev": true }, "node_modules/@types/bn.js": { "version": "4.11.6", @@ -4256,21 +2075,6 @@ "dev": true, "license": "MIT" }, - "node_modules/@types/level-errors": { - "version": "3.0.0", - "dev": true, - "license": "MIT" - }, - "node_modules/@types/levelup": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "@types/abstract-leveldown": "*", - "@types/level-errors": "*", - "@types/node": "*" - } - }, "node_modules/@types/lru-cache": { "version": "5.1.1", "dev": true, @@ -4373,22 +2177,6 @@ } } }, - "node_modules/@typescript-eslint/eslint-plugin/node_modules/debug": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, "node_modules/@typescript-eslint/experimental-utils": { "version": "5.5.0", "dev": true, @@ -4438,22 +2226,6 @@ } } }, - "node_modules/@typescript-eslint/parser/node_modules/debug": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, "node_modules/@typescript-eslint/scope-manager": { "version": "5.5.0", "dev": true, @@ -4508,22 +2280,6 @@ } } }, - "node_modules/@typescript-eslint/typescript-estree/node_modules/debug": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, "node_modules/@typescript-eslint/typescript-estree/node_modules/is-glob": { "version": "4.0.3", "dev": true, @@ -4551,6 +2307,12 @@ "url": "https://opencollective.com/typescript-eslint" } }, + "node_modules/@ungap/promise-all-settled": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz", + "integrity": "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==", + "dev": true + }, "node_modules/@yarnpkg/lockfile": { "version": "1.1.0", "dev": true, @@ -4572,31 +2334,46 @@ "node": ">=6.5" } }, - "node_modules/abstract-leveldown": { - "version": "6.3.0", + "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, - "license": "MIT", "dependencies": { - "buffer": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" + "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": ">=6" + "node": ">=12" } }, - "node_modules/accepts": { - "version": "1.3.7", + "node_modules/abstract-level/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, - "license": "MIT", + "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": { - "mime-types": "~2.1.24", - "negotiator": "0.6.2" - }, - "engines": { - "node": ">= 0.6" + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" } }, "node_modules/acorn": { @@ -4658,6 +2435,19 @@ "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", "dev": true, @@ -4797,11 +2587,6 @@ "node": ">=4" } }, - "node_modules/array-flatten": { - "version": "1.1.1", - "dev": true, - "license": "MIT" - }, "node_modules/array-union": { "version": "2.1.0", "dev": true, @@ -4831,17 +2616,6 @@ "safer-buffer": "~2.1.0" } }, - "node_modules/asn1.js": { - "version": "5.4.1", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0", - "safer-buffer": "^2.1.0" - } - }, "node_modules/assert-plus": { "version": "1.0.0", "dev": true, @@ -4859,26 +2633,23 @@ } }, "node_modules/async": { - "version": "2.6.3", + "version": "2.6.4", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.4.tgz", + "integrity": "sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==", "dev": true, - "license": "MIT", "dependencies": { "lodash": "^4.17.14" } }, "node_modules/async-eventemitter": { "version": "0.2.4", + "resolved": "https://registry.npmjs.org/async-eventemitter/-/async-eventemitter-0.2.4.tgz", + "integrity": "sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw==", "dev": true, - "license": "MIT", "dependencies": { "async": "^2.4.0" } }, - "node_modules/async-limiter": { - "version": "1.0.1", - "dev": true, - "license": "MIT" - }, "node_modules/asynckit": { "version": "0.4.0", "dev": true, @@ -4896,6 +2667,7 @@ "version": "1.0.5", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">= 0.4" }, @@ -4974,6 +2746,27 @@ "dev": true, "license": "MIT" }, + "node_modules/bigint-crypto-utils": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.1.6.tgz", + "integrity": "sha512-k5ljSLHx94jQTW3+18KEfxLJR8/XFBHqhfhEGF48qT8p/jL6EdiG7oNOiiIRGMFh2wEP8kaCXZbVd+5dYkngUg==", + "dev": true, + "dependencies": { + "bigint-mod-arith": "^3.1.0" + }, + "engines": { + "node": ">=10.4.0" + } + }, + "node_modules/bigint-mod-arith": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/bigint-mod-arith/-/bigint-mod-arith-3.1.1.tgz", + "integrity": "sha512-SzFqdncZKXq5uh3oLFZXmzaZEMDsA7ml9l53xKaVGO6/+y26xNwAaTQEg2R+D+d07YduLbKi0dni3YPsR51UDQ==", + "dev": true, + "engines": { + "node": ">=10.4.0" + } + }, "node_modules/bignumber.js": { "version": "9.0.1", "dev": true, @@ -5021,81 +2814,6 @@ "dev": true, "license": "MIT" }, - "node_modules/body-parser": { - "version": "1.19.0", - "dev": true, - "license": "MIT", - "dependencies": { - "bytes": "3.1.0", - "content-type": "~1.0.4", - "debug": "2.6.9", - "depd": "~1.1.2", - "http-errors": "1.7.2", - "iconv-lite": "0.4.24", - "on-finished": "~2.3.0", - "qs": "6.7.0", - "raw-body": "2.4.0", - "type-is": "~1.6.17" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/body-parser/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/body-parser/node_modules/http-errors": { - "version": "1.7.2", - "dev": true, - "license": "MIT", - "dependencies": { - "depd": "~1.1.2", - "inherits": "2.0.3", - "setprototypeof": "1.1.1", - "statuses": ">= 1.5.0 < 2", - "toidentifier": "1.0.0" - }, - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/body-parser/node_modules/inherits": { - "version": "2.0.3", - "dev": true, - "license": "ISC" - }, - "node_modules/body-parser/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, - "node_modules/body-parser/node_modules/qs": { - "version": "6.7.0", - "dev": true, - "license": "BSD-3-Clause", - "engines": { - "node": ">=0.6" - } - }, - "node_modules/body-parser/node_modules/raw-body": { - "version": "2.4.0", - "dev": true, - "license": "MIT", - "dependencies": { - "bytes": "3.1.0", - "http-errors": "1.7.2", - "iconv-lite": "0.4.24", - "unpipe": "1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, "node_modules/brace-expansion": { "version": "1.1.11", "dev": true, @@ -5121,6 +2839,18 @@ "dev": true, "license": "MIT" }, + "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", "dev": true, @@ -5139,62 +2869,6 @@ "safe-buffer": "^5.0.1" } }, - "node_modules/browserify-cipher": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "browserify-aes": "^1.0.4", - "browserify-des": "^1.0.0", - "evp_bytestokey": "^1.0.0" - } - }, - "node_modules/browserify-des": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "cipher-base": "^1.0.1", - "des.js": "^1.0.0", - "inherits": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "node_modules/browserify-rsa": { - "version": "4.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^5.0.0", - "randombytes": "^2.0.1" - } - }, - "node_modules/browserify-rsa/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, - "node_modules/browserify-sign": { - "version": "4.2.1", - "dev": true, - "license": "ISC", - "dependencies": { - "bn.js": "^5.1.1", - "browserify-rsa": "^4.0.1", - "create-hash": "^1.2.0", - "create-hmac": "^1.1.7", - "elliptic": "^6.5.3", - "inherits": "^2.0.4", - "parse-asn1": "^5.1.5", - "readable-stream": "^3.6.0", - "safe-buffer": "^5.2.0" - } - }, - "node_modules/browserify-sign/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, "node_modules/bs58": { "version": "4.0.1", "dev": true, @@ -5213,29 +2887,6 @@ "safe-buffer": "^5.1.2" } }, - "node_modules/buffer": { - "version": "5.7.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "base64-js": "^1.3.1", - "ieee754": "^1.1.13" - } - }, "node_modules/buffer-from": { "version": "1.1.2", "dev": true, @@ -5244,7 +2895,8 @@ "node_modules/buffer-to-arraybuffer": { "version": "0.0.5", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/buffer-xor": { "version": "1.0.3", @@ -5256,6 +2908,7 @@ "dev": true, "hasInstallScript": true, "license": "MIT", + "peer": true, "dependencies": { "node-gyp-build": "^4.2.0" }, @@ -5263,53 +2916,6 @@ "node": ">=6.14.2" } }, - "node_modules/bytes": { - "version": "3.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/cacheable-request": { - "version": "6.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "clone-response": "^1.0.2", - "get-stream": "^5.1.0", - "http-cache-semantics": "^4.0.0", - "keyv": "^3.0.0", - "lowercase-keys": "^2.0.0", - "normalize-url": "^4.1.0", - "responselike": "^1.0.2" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/cacheable-request/node_modules/get-stream": { - "version": "5.2.0", - "dev": true, - "license": "MIT", - "dependencies": { - "pump": "^3.0.0" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/cacheable-request/node_modules/lowercase-keys": { - "version": "2.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/call-bind": { "version": "1.0.2", "dev": true, @@ -5343,6 +2949,15 @@ "dev": true, "license": "Apache-2.0" }, + "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": "5.2.0", "dev": true, @@ -5372,18 +2987,54 @@ } }, "node_modules/chalk": { - "version": "2.4.2", + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, - "license": "MIT", "dependencies": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" }, "engines": { - "node": ">=4" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" } }, + "node_modules/chalk/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/chalk/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/chalk/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/charenc": { "version": "0.0.2", "dev": true, @@ -5401,9 +3052,16 @@ } }, "node_modules/chokidar": { - "version": "3.5.2", + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", "dev": true, - "license": "MIT", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", @@ -5420,41 +3078,11 @@ "fsevents": "~2.3.2" } }, - "node_modules/chownr": { - "version": "1.1.4", - "dev": true, - "license": "ISC" - }, "node_modules/ci-info": { "version": "2.0.0", "dev": true, "license": "MIT" }, - "node_modules/cids": { - "version": "0.7.5", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer": "^5.5.0", - "class-is": "^1.1.0", - "multibase": "~0.6.0", - "multicodec": "^1.0.0", - "multihashes": "~0.4.15" - }, - "engines": { - "node": ">=4.0.0", - "npm": ">=3.0.0" - } - }, - "node_modules/cids/node_modules/multicodec": { - "version": "1.0.4", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer": "^5.6.0", - "varint": "^5.0.0" - } - }, "node_modules/cipher-base": { "version": "1.0.4", "dev": true, @@ -5464,10 +3092,31 @@ "safe-buffer": "^5.0.1" } }, - "node_modules/class-is": { - "version": "1.1.0", + "node_modules/classic-level": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/classic-level/-/classic-level-1.2.0.tgz", + "integrity": "sha512-qw5B31ANxSluWz9xBzklRWTUAJ1SXIdaVKTVS7HcTGKOAmExx65Wo5BUICW+YGORe2FOUaDghoI9ZDxj82QcFg==", "dev": true, - "license": "MIT" + "hasInstallScript": true, + "dependencies": { + "abstract-level": "^1.0.2", + "catering": "^2.1.0", + "module-error": "^1.0.1", + "napi-macros": "~2.0.0", + "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.6.0", @@ -5552,14 +3201,6 @@ "node": ">=6" } }, - "node_modules/clone-response": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "mimic-response": "^1.0.0" - } - }, "node_modules/code-point-at": { "version": "1.1.0", "dev": true, @@ -5661,40 +3302,6 @@ "dev": true, "license": "MIT" }, - "node_modules/content-disposition": { - "version": "0.5.3", - "dev": true, - "license": "MIT", - "dependencies": { - "safe-buffer": "5.1.2" - }, - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/content-disposition/node_modules/safe-buffer": { - "version": "5.1.2", - "dev": true, - "license": "MIT" - }, - "node_modules/content-hash": { - "version": "2.5.2", - "dev": true, - "license": "ISC", - "dependencies": { - "cids": "^0.7.1", - "multicodec": "^0.5.5", - "multihashes": "^0.4.15" - } - }, - "node_modules/content-type": { - "version": "1.0.4", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/cookie": { "version": "0.4.1", "dev": true, @@ -5703,43 +3310,17 @@ "node": ">= 0.6" } }, - "node_modules/cookie-signature": { - "version": "1.0.6", - "dev": true, - "license": "MIT" - }, "node_modules/cookiejar": { "version": "2.1.2", "dev": true, - "license": "MIT" - }, - "node_modules/core-js-pure": { - "version": "3.19.2", - "dev": true, - "hasInstallScript": true, "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/core-js" - } + "peer": true }, "node_modules/core-util-is": { "version": "1.0.2", "dev": true, "license": "MIT" }, - "node_modules/cors": { - "version": "2.8.5", - "dev": true, - "license": "MIT", - "dependencies": { - "object-assign": "^4", - "vary": "^1" - }, - "engines": { - "node": ">= 0.10" - } - }, "node_modules/crc-32": { "version": "1.2.0", "dev": true, @@ -5755,15 +3336,6 @@ "node": ">=0.8" } }, - "node_modules/create-ecdh": { - "version": "4.0.4", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.1.0", - "elliptic": "^6.5.3" - } - }, "node_modules/create-hash": { "version": "1.2.0", "dev": true, @@ -5825,27 +3397,6 @@ "node": "*" } }, - "node_modules/crypto-browserify": { - "version": "3.12.0", - "dev": true, - "license": "MIT", - "dependencies": { - "browserify-cipher": "^1.0.0", - "browserify-sign": "^4.0.0", - "create-ecdh": "^4.0.0", - "create-hash": "^1.1.0", - "create-hmac": "^1.1.0", - "diffie-hellman": "^5.0.0", - "inherits": "^2.0.1", - "pbkdf2": "^3.0.3", - "public-encrypt": "^4.0.0", - "randombytes": "^2.0.0", - "randomfill": "^1.0.3" - }, - "engines": { - "node": "*" - } - }, "node_modules/crypto-js": { "version": "4.1.1", "dev": true, @@ -5855,6 +3406,7 @@ "version": "1.0.1", "dev": true, "license": "ISC", + "peer": true, "dependencies": { "es5-ext": "^0.10.50", "type": "^1.0.1" @@ -5876,9 +3428,10 @@ "dev": true }, "node_modules/debug": { - "version": "4.3.1", + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", "dev": true, - "license": "MIT", "dependencies": { "ms": "2.1.2" }, @@ -5903,6 +3456,7 @@ "version": "0.2.0", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=0.10" } @@ -5911,6 +3465,7 @@ "version": "3.3.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "mimic-response": "^1.0.0" }, @@ -5964,38 +3519,6 @@ "web3-core-helpers": "^1.3.4" } }, - "node_modules/defer-to-connect": { - "version": "1.1.3", - "dev": true, - "license": "MIT" - }, - "node_modules/deferred-leveldown": { - "version": "5.3.0", - "dev": true, - "license": "MIT", - "dependencies": { - "abstract-leveldown": "~6.2.1", - "inherits": "^2.0.3" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/deferred-leveldown/node_modules/abstract-leveldown": { - "version": "6.2.3", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - }, - "engines": { - "node": ">=6" - } - }, "node_modules/define-properties": { "version": "1.1.3", "dev": true, @@ -6023,20 +3546,6 @@ "node": ">= 0.6" } }, - "node_modules/des.js": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0" - } - }, - "node_modules/destroy": { - "version": "1.0.4", - "dev": true, - "license": "MIT" - }, "node_modules/detect-port": { "version": "1.3.0", "dev": true, @@ -6074,14 +3583,16 @@ "node": ">=0.3.1" } }, - "node_modules/diffie-hellman": { - "version": "5.0.3", + "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, - "license": "MIT", "dependencies": { - "bn.js": "^4.1.0", - "miller-rabin": "^4.0.0", - "randombytes": "^2.0.0" + "heap": ">= 0.2.0" + }, + "engines": { + "node": "*" } }, "node_modules/dir-glob": { @@ -6116,7 +3627,8 @@ }, "node_modules/dom-walk": { "version": "0.1.2", - "dev": true + "dev": true, + "peer": true }, "node_modules/dotenv": { "version": "10.0.0", @@ -6139,11 +3651,6 @@ "node": ">=0.10" } }, - "node_modules/duplexer3": { - "version": "0.1.4", - "dev": true, - "license": "BSD-3-Clause" - }, "node_modules/ecc-jsbn": { "version": "0.1.2", "dev": true, @@ -6153,11 +3660,6 @@ "safer-buffer": "^2.1.0" } }, - "node_modules/ee-first": { - "version": "1.1.1", - "dev": true, - "license": "MIT" - }, "node_modules/elliptic": { "version": "6.5.4", "dev": true, @@ -6177,36 +3679,6 @@ "dev": true, "license": "MIT" }, - "node_modules/encodeurl": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/encoding-down": { - "version": "6.3.0", - "dev": true, - "license": "MIT", - "dependencies": { - "abstract-leveldown": "^6.2.1", - "inherits": "^2.0.3", - "level-codec": "^9.0.0", - "level-errors": "^2.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/end-of-stream": { - "version": "1.4.4", - "dev": true, - "license": "MIT", - "dependencies": { - "once": "^1.4.0" - } - }, "node_modules/enquirer": { "version": "2.3.6", "dev": true, @@ -6226,17 +3698,6 @@ "node": ">=6" } }, - "node_modules/errno": { - "version": "0.1.8", - "dev": true, - "license": "MIT", - "dependencies": { - "prr": "~1.0.1" - }, - "bin": { - "errno": "cli.js" - } - }, "node_modules/error-ex": { "version": "1.3.2", "dev": true, @@ -6348,6 +3809,7 @@ "version": "0.10.53", "dev": true, "license": "ISC", + "peer": true, "dependencies": { "es6-iterator": "~2.0.3", "es6-symbol": "~3.1.3", @@ -6358,6 +3820,7 @@ "version": "2.0.3", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "d": "1", "es5-ext": "^0.10.35", @@ -6368,15 +3831,20 @@ "version": "3.1.3", "dev": true, "license": "ISC", + "peer": true, "dependencies": { "d": "^1.0.1", "ext": "^1.1.2" } }, - "node_modules/escape-html": { - "version": "1.0.3", + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", "dev": true, - "license": "MIT" + "engines": { + "node": ">=6" + } }, "node_modules/escape-string-regexp": { "version": "1.0.5", @@ -6613,56 +4081,11 @@ "node": "^12.22.0 || ^14.17.0 || >=16.0.0" } }, - "node_modules/eslint/node_modules/ansi-styles": { - "version": "4.3.0", - "dev": true, - "license": "MIT", - "dependencies": { - "color-convert": "^2.0.1" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } - }, "node_modules/eslint/node_modules/argparse": { "version": "2.0.1", "dev": true, "license": "Python-2.0" }, - "node_modules/eslint/node_modules/chalk": { - "version": "4.1.2", - "dev": true, - "license": "MIT", - "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/eslint/node_modules/color-convert": { - "version": "2.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "color-name": "~1.1.4" - }, - "engines": { - "node": ">=7.0.0" - } - }, - "node_modules/eslint/node_modules/color-name": { - "version": "1.1.4", - "dev": true, - "license": "MIT" - }, "node_modules/eslint/node_modules/cross-spawn": { "version": "7.0.3", "dev": true, @@ -6676,22 +4099,6 @@ "node": ">= 8" } }, - "node_modules/eslint/node_modules/debug": { - "version": "4.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, "node_modules/eslint/node_modules/escape-string-regexp": { "version": "4.0.0", "dev": true, @@ -6745,14 +4152,6 @@ "node": ">=0.10.0" } }, - "node_modules/eslint/node_modules/has-flag": { - "version": "4.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/eslint/node_modules/ignore": { "version": "4.0.6", "dev": true, @@ -6799,17 +4198,6 @@ "node": ">=8" } }, - "node_modules/eslint/node_modules/supports-color": { - "version": "7.2.0", - "dev": true, - "license": "MIT", - "dependencies": { - "has-flag": "^4.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/eslint/node_modules/which": { "version": "2.0.2", "dev": true, @@ -6903,14 +4291,6 @@ "node": ">=0.10.0" } }, - "node_modules/etag": { - "version": "1.8.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/eth-ens-namehash": { "version": "2.0.8", "dev": true, @@ -7066,37 +4446,13 @@ "version": "0.2.8", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "bn.js": "^4.11.6", "elliptic": "^6.4.0", "xhr-request-promise": "^0.1.2" } }, - "node_modules/eth-sig-util": { - "version": "2.5.4", - "dev": true, - "license": "ISC", - "dependencies": { - "ethereumjs-abi": "0.6.8", - "ethereumjs-util": "^5.1.1", - "tweetnacl": "^1.0.3", - "tweetnacl-util": "^0.15.0" - } - }, - "node_modules/eth-sig-util/node_modules/ethereumjs-util": { - "version": "5.2.1", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "bn.js": "^4.11.0", - "create-hash": "^1.1.2", - "elliptic": "^6.5.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "^0.1.3", - "rlp": "^2.0.0", - "safe-buffer": "^5.1.1" - } - }, "node_modules/ethereum-bloom-filters": { "version": "1.0.9", "dev": true, @@ -7147,6 +4503,7 @@ }, "node_modules/ethereumjs-abi": { "version": "0.6.8", + "resolved": "git+ssh://git@github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0", "dev": true, "license": "MIT", "dependencies": { @@ -7154,10 +4511,11 @@ "ethereumjs-util": "^6.0.0" } }, - "node_modules/ethereumjs-abi/node_modules/ethereumjs-util": { + "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, - "license": "MPL-2.0", "dependencies": { "@types/bn.js": "^4.11.3", "bn.js": "^4.11.0", @@ -7168,36 +4526,10 @@ "rlp": "^2.2.3" } }, - "node_modules/ethereumjs-util": { - "version": "7.1.3", - "dev": true, - "license": "MPL-2.0", - "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/ethereumjs-util/node_modules/@types/bn.js": { - "version": "5.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/ethereumjs-util/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, "node_modules/ethers": { - "version": "5.5.1", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.1.tgz", + "integrity": "sha512-5krze4dRLITX7FpU8J4WscXqADiKmyeNlylmmDLbS95DaZpBhDe2YSwRQwKXWNyXcox7a3gBgm/MkGXV1O1S/Q==", "dev": true, "funding": [ { @@ -7209,411 +4541,37 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], - "license": "MIT", "dependencies": { - "@ethersproject/abi": "5.5.0", - "@ethersproject/abstract-provider": "5.5.1", - "@ethersproject/abstract-signer": "5.5.0", - "@ethersproject/address": "5.5.0", - "@ethersproject/base64": "5.5.0", - "@ethersproject/basex": "5.5.0", - "@ethersproject/bignumber": "5.5.0", - "@ethersproject/bytes": "5.5.0", - "@ethersproject/constants": "5.5.0", - "@ethersproject/contracts": "5.5.0", - "@ethersproject/hash": "5.5.0", - "@ethersproject/hdnode": "5.5.0", - "@ethersproject/json-wallets": "5.5.0", - "@ethersproject/keccak256": "5.5.0", - "@ethersproject/logger": "5.5.0", - "@ethersproject/networks": "5.5.0", - "@ethersproject/pbkdf2": "5.5.0", - "@ethersproject/properties": "5.5.0", - "@ethersproject/providers": "5.5.0", - "@ethersproject/random": "5.5.0", - "@ethersproject/rlp": "5.5.0", - "@ethersproject/sha2": "5.5.0", - "@ethersproject/signing-key": "5.5.0", - "@ethersproject/solidity": "5.5.0", - "@ethersproject/strings": "5.5.0", - "@ethersproject/transactions": "5.5.0", - "@ethersproject/units": "5.5.0", - "@ethersproject/wallet": "5.5.0", - "@ethersproject/web": "5.5.0", - "@ethersproject/wordlists": "5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/abi": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/abstract-provider": { - "version": "5.5.1", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/abstract-signer": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/address": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/base64": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/bignumber": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "node_modules/ethers/node_modules/@ethersproject/bytes": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/constants": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/hash": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/keccak256": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/logger": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT" - }, - "node_modules/ethers/node_modules/@ethersproject/networks": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/properties": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/rlp": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/signing-key": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "node_modules/ethers/node_modules/@ethersproject/strings": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/transactions": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "node_modules/ethers/node_modules/@ethersproject/web": { - "version": "5.5.0", - "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" - } - ], - "license": "MIT", - "dependencies": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" + "@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.1", + "@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": { @@ -7658,7 +4616,8 @@ "node_modules/eventemitter3": { "version": "4.0.4", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/evp_bytestokey": { "version": "1.0.3", @@ -7677,84 +4636,11 @@ "node": ">=0.8" } }, - "node_modules/express": { - "version": "4.17.1", - "dev": true, - "license": "MIT", - "dependencies": { - "accepts": "~1.3.7", - "array-flatten": "1.1.1", - "body-parser": "1.19.0", - "content-disposition": "0.5.3", - "content-type": "~1.0.4", - "cookie": "0.4.0", - "cookie-signature": "1.0.6", - "debug": "2.6.9", - "depd": "~1.1.2", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "~1.1.2", - "fresh": "0.5.2", - "merge-descriptors": "1.0.1", - "methods": "~1.1.2", - "on-finished": "~2.3.0", - "parseurl": "~1.3.3", - "path-to-regexp": "0.1.7", - "proxy-addr": "~2.0.5", - "qs": "6.7.0", - "range-parser": "~1.2.1", - "safe-buffer": "5.1.2", - "send": "0.17.1", - "serve-static": "1.14.1", - "setprototypeof": "1.1.1", - "statuses": "~1.5.0", - "type-is": "~1.6.18", - "utils-merge": "1.0.1", - "vary": "~1.1.2" - }, - "engines": { - "node": ">= 0.10.0" - } - }, - "node_modules/express/node_modules/cookie": { - "version": "0.4.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/express/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/express/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, - "node_modules/express/node_modules/qs": { - "version": "6.7.0", - "dev": true, - "license": "BSD-3-Clause", - "engines": { - "node": ">=0.6" - } - }, - "node_modules/express/node_modules/safe-buffer": { - "version": "5.1.2", - "dev": true, - "license": "MIT" - }, "node_modules/ext": { "version": "1.6.0", "dev": true, "license": "ISC", + "peer": true, "dependencies": { "type": "^2.5.0" } @@ -7762,7 +4648,8 @@ "node_modules/ext/node_modules/type": { "version": "2.5.0", "dev": true, - "license": "ISC" + "license": "ISC", + "peer": true }, "node_modules/extend": { "version": "3.0.2", @@ -7853,36 +4740,6 @@ "node": ">=8" } }, - "node_modules/finalhandler": { - "version": "1.1.2", - "dev": true, - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "on-finished": "~2.3.0", - "parseurl": "~1.3.3", - "statuses": "~1.5.0", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/finalhandler/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/finalhandler/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, "node_modules/find-replace": { "version": "1.0.3", "dev": true, @@ -7994,7 +4851,8 @@ "node_modules/foreach": { "version": "2.0.5", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/forever-agent": { "version": "0.6.1", @@ -8017,27 +4875,11 @@ "node": ">= 6" } }, - "node_modules/forwarded": { - "version": "0.2.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/fp-ts": { "version": "1.19.3", "dev": true, "license": "MIT" }, - "node_modules/fresh": { - "version": "0.5.2", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/fs-extra": { "version": "7.0.1", "dev": true, @@ -8051,14 +4893,6 @@ "node": ">=6 <7 || >=8" } }, - "node_modules/fs-minipass": { - "version": "1.2.7", - "dev": true, - "license": "ISC", - "dependencies": { - "minipass": "^2.6.0" - } - }, "node_modules/fs-readdir-recursive": { "version": "1.1.0", "dev": true, @@ -8069,6 +4903,20 @@ "dev": true, "license": "ISC" }, + "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", "dev": true, @@ -8079,1054 +4927,6 @@ "dev": true, "license": "MIT" }, - "node_modules/ganache-cli": { - "version": "6.12.2", - "bundleDependencies": [ - "source-map-support", - "yargs", - "ethereumjs-util" - ], - "dev": true, - "license": "MIT", - "dependencies": { - "ethereumjs-util": "6.2.1", - "source-map-support": "0.5.12", - "yargs": "13.2.4" - }, - "bin": { - "ganache-cli": "cli.js" - } - }, - "node_modules/ganache-cli/node_modules/@types/bn.js": { - "version": "4.11.6", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/ganache-cli/node_modules/@types/node": { - "version": "14.11.2", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/@types/pbkdf2": { - "version": "3.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/ganache-cli/node_modules/@types/secp256k1": { - "version": "4.0.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/ganache-cli/node_modules/ansi-regex": { - "version": "4.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/ansi-styles": { - "version": "3.2.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "color-convert": "^1.9.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/base-x": { - "version": "3.0.8", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "safe-buffer": "^5.0.1" - } - }, - "node_modules/ganache-cli/node_modules/blakejs": { - "version": "1.1.0", - "dev": true, - "inBundle": true, - "license": "CC0-1.0" - }, - "node_modules/ganache-cli/node_modules/bn.js": { - "version": "4.11.9", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/brorand": { - "version": "1.1.0", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/browserify-aes": { - "version": "1.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "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/ganache-cli/node_modules/bs58": { - "version": "4.0.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "base-x": "^3.0.2" - } - }, - "node_modules/ganache-cli/node_modules/bs58check": { - "version": "2.1.2", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "bs58": "^4.0.0", - "create-hash": "^1.1.0", - "safe-buffer": "^5.1.2" - } - }, - "node_modules/ganache-cli/node_modules/buffer-from": { - "version": "1.1.1", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/buffer-xor": { - "version": "1.0.3", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/camelcase": { - "version": "5.3.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/cipher-base": { - "version": "1.0.4", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" - } - }, - "node_modules/ganache-cli/node_modules/cliui": { - "version": "5.0.0", - "dev": true, - "inBundle": true, - "license": "ISC", - "dependencies": { - "string-width": "^3.1.0", - "strip-ansi": "^5.2.0", - "wrap-ansi": "^5.1.0" - } - }, - "node_modules/ganache-cli/node_modules/color-convert": { - "version": "1.9.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "color-name": "1.1.3" - } - }, - "node_modules/ganache-cli/node_modules/color-name": { - "version": "1.1.3", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/create-hash": { - "version": "1.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "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/ganache-cli/node_modules/create-hmac": { - "version": "1.1.7", - "dev": true, - "inBundle": true, - "license": "MIT", - "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/ganache-cli/node_modules/cross-spawn": { - "version": "6.0.5", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "nice-try": "^1.0.4", - "path-key": "^2.0.1", - "semver": "^5.5.0", - "shebang-command": "^1.2.0", - "which": "^1.2.9" - }, - "engines": { - "node": ">=4.8" - } - }, - "node_modules/ganache-cli/node_modules/decamelize": { - "version": "1.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/elliptic": { - "version": "6.5.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.4.0", - "brorand": "^1.0.1", - "hash.js": "^1.0.0", - "hmac-drbg": "^1.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.0" - } - }, - "node_modules/ganache-cli/node_modules/emoji-regex": { - "version": "7.0.3", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/end-of-stream": { - "version": "1.4.4", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "once": "^1.4.0" - } - }, - "node_modules/ganache-cli/node_modules/ethereum-cryptography": { - "version": "0.1.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "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/ganache-cli/node_modules/ethereumjs-util": { - "version": "6.2.1", - "dev": true, - "inBundle": true, - "license": "MPL-2.0", - "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/ganache-cli/node_modules/ethjs-util": { - "version": "0.1.6", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "is-hex-prefixed": "1.0.0", - "strip-hex-prefix": "1.0.0" - }, - "engines": { - "node": ">=6.5.0", - "npm": ">=3" - } - }, - "node_modules/ganache-cli/node_modules/evp_bytestokey": { - "version": "1.0.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "md5.js": "^1.3.4", - "safe-buffer": "^5.1.1" - } - }, - "node_modules/ganache-cli/node_modules/execa": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "cross-spawn": "^6.0.0", - "get-stream": "^4.0.0", - "is-stream": "^1.1.0", - "npm-run-path": "^2.0.0", - "p-finally": "^1.0.0", - "signal-exit": "^3.0.0", - "strip-eof": "^1.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/find-up": { - "version": "3.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "locate-path": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/get-caller-file": { - "version": "2.0.5", - "dev": true, - "inBundle": true, - "license": "ISC", - "engines": { - "node": "6.* || 8.* || >= 10.*" - } - }, - "node_modules/ganache-cli/node_modules/get-stream": { - "version": "4.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "pump": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/hash-base": { - "version": "3.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.4", - "readable-stream": "^3.6.0", - "safe-buffer": "^5.2.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/hash.js": { - "version": "1.1.7", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "minimalistic-assert": "^1.0.1" - } - }, - "node_modules/ganache-cli/node_modules/hmac-drbg": { - "version": "1.0.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "hash.js": "^1.0.3", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.1" - } - }, - "node_modules/ganache-cli/node_modules/inherits": { - "version": "2.0.4", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/invert-kv": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/is-fullwidth-code-point": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/is-hex-prefixed": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6.5.0", - "npm": ">=3" - } - }, - "node_modules/ganache-cli/node_modules/is-stream": { - "version": "1.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/isexe": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/keccak": { - "version": "3.0.1", - "dev": true, - "hasInstallScript": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" - }, - "engines": { - "node": ">=10.0.0" - } - }, - "node_modules/ganache-cli/node_modules/lcid": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "invert-kv": "^2.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/locate-path": { - "version": "3.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "p-locate": "^3.0.0", - "path-exists": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/map-age-cleaner": { - "version": "0.1.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "p-defer": "^1.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/md5.js": { - "version": "1.3.5", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "node_modules/ganache-cli/node_modules/mem": { - "version": "4.3.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "map-age-cleaner": "^0.1.1", - "mimic-fn": "^2.0.0", - "p-is-promise": "^2.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/mimic-fn": { - "version": "2.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/minimalistic-assert": { - "version": "1.0.1", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/minimalistic-crypto-utils": { - "version": "1.0.1", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/nice-try": { - "version": "1.0.5", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/node-addon-api": { - "version": "2.0.2", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/node-gyp-build": { - "version": "4.2.3", - "dev": true, - "inBundle": true, - "license": "MIT", - "bin": { - "node-gyp-build": "bin.js", - "node-gyp-build-optional": "optional.js", - "node-gyp-build-test": "build-test.js" - } - }, - "node_modules/ganache-cli/node_modules/npm-run-path": { - "version": "2.0.2", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "path-key": "^2.0.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/once": { - "version": "1.4.0", - "dev": true, - "inBundle": true, - "license": "ISC", - "dependencies": { - "wrappy": "1" - } - }, - "node_modules/ganache-cli/node_modules/os-locale": { - "version": "3.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "execa": "^1.0.0", - "lcid": "^2.0.0", - "mem": "^4.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/p-defer": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/p-finally": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/p-is-promise": { - "version": "2.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/p-limit": { - "version": "2.3.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "p-try": "^2.0.0" - }, - "engines": { - "node": ">=6" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/ganache-cli/node_modules/p-locate": { - "version": "3.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "p-limit": "^2.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/p-try": { - "version": "2.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/path-exists": { - "version": "3.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/path-key": { - "version": "2.0.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/ganache-cli/node_modules/pbkdf2": { - "version": "3.1.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "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/ganache-cli/node_modules/pump": { - "version": "3.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "node_modules/ganache-cli/node_modules/randombytes": { - "version": "2.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "safe-buffer": "^5.1.0" - } - }, - "node_modules/ganache-cli/node_modules/readable-stream": { - "version": "3.6.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "string_decoder": "^1.1.1", - "util-deprecate": "^1.0.1" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/ganache-cli/node_modules/require-directory": { - "version": "2.1.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/require-main-filename": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/ripemd160": { - "version": "2.0.2", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1" - } - }, - "node_modules/ganache-cli/node_modules/rlp": { - "version": "2.2.6", - "dev": true, - "inBundle": true, - "license": "MPL-2.0", - "dependencies": { - "bn.js": "^4.11.1" - }, - "bin": { - "rlp": "bin/rlp" - } - }, - "node_modules/ganache-cli/node_modules/safe-buffer": { - "version": "5.2.1", - "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" - } - ], - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/scrypt-js": { - "version": "3.0.1", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/secp256k1": { - "version": "4.0.2", - "dev": true, - "hasInstallScript": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "elliptic": "^6.5.2", - "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" - }, - "engines": { - "node": ">=10.0.0" - } - }, - "node_modules/ganache-cli/node_modules/semver": { - "version": "5.7.1", - "dev": true, - "inBundle": true, - "license": "ISC", - "bin": { - "semver": "bin/semver" - } - }, - "node_modules/ganache-cli/node_modules/set-blocking": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/setimmediate": { - "version": "1.0.5", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/sha.js": { - "version": "2.4.11", - "dev": true, - "inBundle": true, - "license": "(MIT AND BSD-3-Clause)", - "dependencies": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" - }, - "bin": { - "sha.js": "bin.js" - } - }, - "node_modules/ganache-cli/node_modules/shebang-command": { - "version": "1.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "shebang-regex": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/shebang-regex": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/signal-exit": { - "version": "3.0.3", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/source-map": { - "version": "0.6.1", - "dev": true, - "inBundle": true, - "license": "BSD-3-Clause", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/source-map-support": { - "version": "0.5.12", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "buffer-from": "^1.0.0", - "source-map": "^0.6.0" - } - }, - "node_modules/ganache-cli/node_modules/string_decoder": { - "version": "1.3.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "safe-buffer": "~5.2.0" - } - }, - "node_modules/ganache-cli/node_modules/string-width": { - "version": "3.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/strip-ansi": { - "version": "5.2.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "ansi-regex": "^4.1.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/strip-eof": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ganache-cli/node_modules/strip-hex-prefix": { - "version": "1.0.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "is-hex-prefixed": "1.0.0" - }, - "engines": { - "node": ">=6.5.0", - "npm": ">=3" - } - }, - "node_modules/ganache-cli/node_modules/util-deprecate": { - "version": "1.0.2", - "dev": true, - "inBundle": true, - "license": "MIT" - }, - "node_modules/ganache-cli/node_modules/which": { - "version": "1.3.1", - "dev": true, - "inBundle": true, - "license": "ISC", - "dependencies": { - "isexe": "^2.0.0" - }, - "bin": { - "which": "bin/which" - } - }, - "node_modules/ganache-cli/node_modules/which-module": { - "version": "2.0.0", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/wrap-ansi": { - "version": "5.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "ansi-styles": "^3.2.0", - "string-width": "^3.0.0", - "strip-ansi": "^5.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/ganache-cli/node_modules/wrappy": { - "version": "1.0.2", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/y18n": { - "version": "4.0.0", - "dev": true, - "inBundle": true, - "license": "ISC" - }, - "node_modules/ganache-cli/node_modules/yargs": { - "version": "13.2.4", - "dev": true, - "inBundle": true, - "license": "MIT", - "dependencies": { - "cliui": "^5.0.0", - "find-up": "^3.0.0", - "get-caller-file": "^2.0.1", - "os-locale": "^3.1.0", - "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.0" - } - }, - "node_modules/ganache-cli/node_modules/yargs-parser": { - "version": "13.1.2", - "dev": true, - "inBundle": true, - "license": "ISC", - "dependencies": { - "camelcase": "^5.0.0", - "decamelize": "^1.2.0" - } - }, "node_modules/ganache-core": { "version": "2.13.2", "bundleDependencies": [ @@ -9189,368 +4989,6 @@ "@ethersproject/strings": ">=5.0.0-beta.130" } }, - "node_modules/ganache-core/node_modules/@ethersproject/abstract-provider": { - "version": "5.0.8", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/networks": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/web": "^5.0.12" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/abstract-signer": { - "version": "5.0.10", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/address": { - "version": "5.0.9", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/rlp": "^5.0.7" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/base64": { - "version": "5.0.7", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/bignumber": { - "version": "5.0.13", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "bn.js": "^4.4.0" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/bytes": { - "version": "5.0.9", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/logger": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/constants": { - "version": "5.0.8", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bignumber": "^5.0.13" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/hash": { - "version": "5.0.10", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/keccak256": { - "version": "5.0.7", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9", - "js-sha3": "0.5.7" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/logger": { - "version": "5.0.8", - "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" - } - ], - "license": "MIT", - "optional": true - }, - "node_modules/ganache-core/node_modules/@ethersproject/networks": { - "version": "5.0.7", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/logger": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/properties": { - "version": "5.0.7", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/logger": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/rlp": { - "version": "5.0.7", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/signing-key": { - "version": "5.0.8", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "elliptic": "6.5.3" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/strings": { - "version": "5.0.8", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/logger": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/transactions": { - "version": "5.0.9", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/rlp": "^5.0.7", - "@ethersproject/signing-key": "^5.0.8" - } - }, - "node_modules/ganache-core/node_modules/@ethersproject/web": { - "version": "5.0.12", - "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" - } - ], - "license": "MIT", - "optional": true, - "dependencies": { - "@ethersproject/base64": "^5.0.7", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" - } - }, "node_modules/ganache-core/node_modules/@sindresorhus/is": { "version": "0.14.0", "dev": true, @@ -9744,14 +5182,6 @@ "lodash": "^4.17.11" } }, - "node_modules/ganache-core/node_modules/async-eventemitter": { - "version": "0.2.4", - "dev": true, - "license": "MIT", - "dependencies": { - "async": "^2.4.0" - } - }, "node_modules/ganache-core/node_modules/async-limiter": { "version": "1.0.1", "dev": true, @@ -12620,15 +8050,6 @@ "setimmediate": "^1.0.5" } }, - "node_modules/ganache-core/node_modules/ethereumjs-abi": { - "version": "0.6.8", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.11.8", - "ethereumjs-util": "^6.0.0" - } - }, "node_modules/ganache-core/node_modules/ethereumjs-account": { "version": "3.0.0", "dev": true, @@ -12865,20 +8286,6 @@ "ethereumjs-util": "^6.0.0" } }, - "node_modules/ganache-core/node_modules/ethereumjs-util": { - "version": "6.2.1", - "dev": true, - "license": "MPL-2.0", - "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/ganache-core/node_modules/ethereumjs-vm": { "version": "4.2.0", "dev": true, @@ -13808,22 +9215,6 @@ "assert-plus": "^1.0.0" } }, - "node_modules/ganache-core/node_modules/glob": { - "version": "7.1.3", - "dev": true, - "license": "ISC", - "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/ganache-core/node_modules/global": { "version": "4.4.0", "dev": true, @@ -16110,11 +11501,6 @@ "rlp": "bin/rlp" } }, - "node_modules/ganache-core/node_modules/rustbn.js": { - "version": "0.2.0", - "dev": true, - "license": "(MIT OR Apache-2.0)" - }, "node_modules/ganache-core/node_modules/safe-buffer": { "version": "5.2.1", "dev": true, @@ -17172,16 +12558,6 @@ "node": "*" } }, - "node_modules/ganache-core/node_modules/tweetnacl": { - "version": "1.0.3", - "dev": true, - "license": "Unlicense" - }, - "node_modules/ganache-core/node_modules/tweetnacl-util": { - "version": "0.15.1", - "dev": true, - "license": "Unlicense" - }, "node_modules/ganache-core/node_modules/type": { "version": "1.2.0", "dev": true, @@ -17821,29 +13197,6 @@ "ethereumjs-util": "^5.1.1" } }, - "node_modules/ganache-core/node_modules/web3-provider-engine/node_modules/ethereumjs-abi": { - "version": "0.6.8", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.11.8", - "ethereumjs-util": "^6.0.0" - } - }, - "node_modules/ganache-core/node_modules/web3-provider-engine/node_modules/ethereumjs-abi/node_modules/ethereumjs-util": { - "version": "6.2.1", - "dev": true, - "license": "MPL-2.0", - "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/ganache-core/node_modules/web3-provider-engine/node_modules/ethereumjs-account": { "version": "2.0.5", "dev": true, @@ -18367,17 +13720,6 @@ "node": ">=4" } }, - "node_modules/get-stream": { - "version": "4.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "pump": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, "node_modules/get-symbol-description": { "version": "1.0.0", "dev": true, @@ -18413,10 +13755,37 @@ "testrpc-sc": "index.js" } }, - "node_modules/glob": { - "version": "7.1.6", + "node_modules/ghost-testrpc/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/ghost-testrpc/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/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", "dev": true, - "license": "ISC", "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", @@ -18447,6 +13816,7 @@ "version": "4.4.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "min-document": "^2.19.0", "process": "^0.11.10" @@ -18509,27 +13879,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/got": { - "version": "9.6.0", - "dev": true, - "license": "MIT", - "dependencies": { - "@sindresorhus/is": "^0.14.0", - "@szmarczak/http-timer": "^1.1.2", - "cacheable-request": "^6.0.0", - "decompress-response": "^3.3.0", - "duplexer3": "^0.1.4", - "get-stream": "^4.1.0", - "lowercase-keys": "^1.0.1", - "mimic-response": "^1.0.1", - "p-cancelable": "^1.0.0", - "to-readable-stream": "^1.0.0", - "url-parse-lax": "^3.0.0" - }, - "engines": { - "node": ">=8.6" - } - }, "node_modules/graceful-fs": { "version": "4.2.6", "dev": true, @@ -18584,22 +13933,30 @@ } }, "node_modules/hardhat": { - "version": "2.7.0", + "version": "2.12.0", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.12.0.tgz", + "integrity": "sha512-mNJFbVG479HwOzxiaLxobyvED2M1aEAuPPYhEo1+88yicMDSTrU2JIS7vV+V0GSNQKaDoiHCmV6bcKjiljT/dQ==", "dev": true, - "license": "SEE LICENSE IN LICENSE", "dependencies": { - "@ethereumjs/block": "^3.4.0", - "@ethereumjs/blockchain": "^5.4.0", - "@ethereumjs/common": "^2.4.0", - "@ethereumjs/tx": "^3.3.0", - "@ethereumjs/vm": "^5.5.2", "@ethersproject/abi": "^5.1.2", + "@metamask/eth-sig-util": "^4.0.0", + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-blockchain": "^6.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-evm": "^1.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-statemanager": "^1.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@nomicfoundation/ethereumjs-vm": "^6.0.0", + "@nomicfoundation/solidity-analyzer": "^0.1.0", "@sentry/node": "^5.18.1", - "@solidity-parser/parser": "^0.14.0", "@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", @@ -18607,32 +13964,28 @@ "debug": "^4.1.1", "enquirer": "^2.3.0", "env-paths": "^2.2.0", - "eth-sig-util": "^2.5.2", - "ethereum-cryptography": "^0.1.2", + "ethereum-cryptography": "^1.0.3", "ethereumjs-abi": "^0.6.8", - "ethereumjs-util": "^7.1.0", "find-up": "^2.1.0", "fp-ts": "1.19.3", "fs-extra": "^7.0.1", - "glob": "^7.1.3", - "https-proxy-agent": "^5.0.0", + "glob": "7.2.0", "immutable": "^4.0.0-rc.12", "io-ts": "1.10.4", + "keccak": "^3.0.2", "lodash": "^4.17.11", - "merkle-patricia-tree": "^4.2.0", "mnemonist": "^0.38.0", - "mocha": "^7.1.2", - "node-fetch": "^2.6.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", - "slash": "^3.0.0", "solc": "0.7.3", "source-map-support": "^0.5.13", "stacktrace-parser": "^0.1.10", - "true-case-path": "^2.2.1", "tsort": "0.0.1", + "undici": "^5.4.0", "uuid": "^8.3.2", "ws": "^7.4.6" }, @@ -18640,7 +13993,19 @@ "hardhat": "internal/cli/cli.js" }, "engines": { - "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + "node": "^14.0.0 || ^16.0.0 || ^18.0.0" + }, + "peerDependencies": { + "ts-node": "*", + "typescript": "*" + }, + "peerDependenciesMeta": { + "ts-node": { + "optional": true + }, + "typescript": { + "optional": true + } } }, "node_modules/hardhat-contract-sizer": { @@ -18684,6 +14049,20 @@ "hardhat": "^2.0.0" } }, + "node_modules/hardhat-tracer": { + "version": "1.1.0-rc.6", + "resolved": "https://registry.npmjs.org/hardhat-tracer/-/hardhat-tracer-1.1.0-rc.6.tgz", + "integrity": "sha512-u1d8YpyYBCj/7xVMPDxsx+H1gBaothk/XNLeTYuEmxC6WmVMEwVjpdnmTYZiRQ2ntUfwSIjwKhDkLOqewBqaQA==", + "dev": true, + "dependencies": { + "ethers": "^5.6.1" + }, + "peerDependencies": { + "chalk": "4.x", + "ethers": "5.x", + "hardhat": "2.x" + } + }, "node_modules/hardhat/node_modules/@types/bn.js": { "version": "5.1.0", "dev": true, @@ -18692,6 +14071,387 @@ "@types/node": "*" } }, + "node_modules/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/node_modules/ethereum-cryptography": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.1.2.tgz", + "integrity": "sha512-XDSJlg4BD+hq9N2FjvotwUET9Tfxpxc3kWGE2AqUG5vcbeunnbImVk3cj6e/xT3phdW21mE8R5IugU4fspQDcQ==", + "dev": true, + "dependencies": { + "@noble/hashes": "1.1.2", + "@noble/secp256k1": "1.6.3", + "@scure/bip32": "1.1.0", + "@scure/bip39": "1.1.0" + } + }, + "node_modules/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/node_modules/mocha": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.0.0.tgz", + "integrity": "sha512-0Wl+elVUD43Y0BqPZBzZt8Tnkw9CMUdNYnUsTfOM1vuhJVZL+kiesFYsqwBkEEuEixaiPe5ZQdqDgX2jddhmoA==", + "dev": true, + "dependencies": { + "@ungap/promise-all-settled": "1.1.2", + "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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/node_modules/semver": { "version": "6.3.0", "dev": true, @@ -18700,6 +14460,32 @@ "semver": "bin/semver.js" } }, + "node_modules/hardhat/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/hardhat/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/hardhat/node_modules/uuid": { "version": "8.3.2", "dev": true, @@ -18708,6 +14494,89 @@ "uuid": "dist/bin/uuid" } }, + "node_modules/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/hardhat/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/has": { "version": "1.0.3", "dev": true, @@ -18735,14 +14604,6 @@ "node": ">=4" } }, - "node_modules/has-symbol-support-x": { - "version": "1.4.2", - "dev": true, - "license": "MIT", - "engines": { - "node": "*" - } - }, "node_modules/has-symbols": { "version": "1.0.2", "dev": true, @@ -18754,17 +14615,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/has-to-string-tag-x": { - "version": "1.4.1", - "dev": true, - "license": "MIT", - "dependencies": { - "has-symbol-support-x": "^1.4.1" - }, - "engines": { - "node": "*" - } - }, "node_modules/has-tostringtag": { "version": "1.0.0", "dev": true, @@ -18822,6 +14672,12 @@ "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 + }, "node_modules/hmac-drbg": { "version": "1.0.1", "dev": true, @@ -18851,30 +14707,11 @@ "node": ">=6.0.0" } }, - "node_modules/http-cache-semantics": { - "version": "4.1.0", - "dev": true, - "license": "BSD-2-Clause" - }, - "node_modules/http-errors": { - "version": "1.7.3", - "dev": true, - "license": "MIT", - "dependencies": { - "depd": "~1.1.2", - "inherits": "2.0.4", - "setprototypeof": "1.1.1", - "statuses": ">= 1.5.0 < 2", - "toidentifier": "1.0.0" - }, - "engines": { - "node": ">= 0.6" - } - }, "node_modules/http-https": { "version": "1.0.0", "dev": true, - "license": "ISC" + "license": "ISC", + "peer": true }, "node_modules/http-response-object": { "version": "3.0.2", @@ -18978,11 +14815,6 @@ "node": ">= 4" } }, - "node_modules/immediate": { - "version": "3.3.0", - "dev": true, - "license": "MIT" - }, "node_modules/immutable": { "version": "4.0.0", "dev": true, @@ -19011,6 +14843,15 @@ "node": ">=0.8.19" } }, + "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", "dev": true, @@ -19067,18 +14908,11 @@ "fp-ts": "^1.0.0" } }, - "node_modules/ipaddr.js": { - "version": "1.9.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.10" - } - }, "node_modules/is-arguments": { "version": "1.1.1", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -19216,12 +15050,14 @@ "node_modules/is-function": { "version": "1.0.2", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/is-generator-function": { "version": "1.0.10", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "has-tostringtag": "^1.0.0" }, @@ -19282,22 +15118,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-object": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/is-plain-obj": { - "version": "1.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/is-regex": { "version": "1.1.4", "dev": true, @@ -19313,14 +15133,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-retry-allowed": { - "version": "1.2.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/is-shared-array-buffer": { "version": "1.0.1", "dev": true, @@ -19329,14 +15141,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-stream": { - "version": "1.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/is-string": { "version": "1.0.5", "dev": true, @@ -19366,6 +15170,7 @@ "version": "1.1.8", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "available-typed-arrays": "^1.0.5", "call-bind": "^1.0.2", @@ -19384,6 +15189,7 @@ "version": "1.18.6", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", @@ -19415,6 +15221,7 @@ "version": "1.2.4", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">= 0.4" }, @@ -19426,6 +15233,7 @@ "version": "1.1.4", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -19441,6 +15249,7 @@ "version": "1.0.7", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "has-tostringtag": "^1.0.0" }, @@ -19455,6 +15264,7 @@ "version": "1.11.0", "dev": true, "license": "MIT", + "peer": true, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -19463,6 +15273,7 @@ "version": "4.1.2", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", @@ -19481,6 +15292,18 @@ "dev": true, "license": "MIT" }, + "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-url": { "version": "1.2.4", "dev": true, @@ -19537,18 +15360,6 @@ "dev": true, "license": "MIT" }, - "node_modules/isurl": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "has-to-string-tag-x": "^1.2.0", - "is-object": "^1.0.1" - }, - "engines": { - "node": ">= 4" - } - }, "node_modules/js-cookie": { "version": "2.2.1", "dev": true, @@ -19576,11 +15387,6 @@ "dev": true, "license": "MIT" }, - "node_modules/json-buffer": { - "version": "3.0.0", - "dev": true, - "license": "MIT" - }, "node_modules/json-schema": { "version": "0.2.3", "dev": true @@ -19631,26 +15437,20 @@ } }, "node_modules/keccak": { - "version": "3.0.1", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.2.tgz", + "integrity": "sha512-PyKKjkH53wDMLGrvmRGSNWgmSxZOUqbnXwKL9tmgbFYA1iAYqW21kfR7mZXV0MlESiefxQQE9X9fTa3X+2MPDQ==", "dev": true, "hasInstallScript": true, - "license": "MIT", "dependencies": { "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" }, "engines": { "node": ">=10.0.0" } }, - "node_modules/keyv": { - "version": "3.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "json-buffer": "3.0.0" - } - }, "node_modules/kind-of": { "version": "6.0.3", "dev": true, @@ -19686,110 +15486,67 @@ "node": ">=0.10.0" } }, - "node_modules/level-codec": { - "version": "9.0.2", + "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, - "license": "MIT", "dependencies": { - "buffer": "^5.6.0" + "browser-level": "^1.0.1", + "classic-level": "^1.2.0" }, "engines": { - "node": ">=6" - } - }, - "node_modules/level-concat-iterator": { - "version": "2.0.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/level-errors": { - "version": "2.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "errno": "~0.1.1" + "node": ">=12" }, - "engines": { - "node": ">=6" - } - }, - "node_modules/level-iterator-stream": { - "version": "4.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "inherits": "^2.0.4", - "readable-stream": "^3.4.0", - "xtend": "^4.0.2" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/level-mem": { - "version": "5.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "level-packager": "^5.0.3", - "memdown": "^5.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/level-packager": { - "version": "5.1.1", - "dev": true, - "license": "MIT", - "dependencies": { - "encoding-down": "^6.3.0", - "levelup": "^4.3.2" - }, - "engines": { - "node": ">=6" + "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, - "license": "MIT", "dependencies": { - "xtend": "^4.0.2" + "buffer": "^6.0.3", + "module-error": "^1.0.1" }, "engines": { - "node": ">=6" + "node": ">=12" } }, - "node_modules/level-ws": { - "version": "2.0.0", + "node_modules/level-transcoder/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, - "license": "MIT", + "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": { - "inherits": "^2.0.3", - "readable-stream": "^3.1.0", - "xtend": "^4.0.1" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/levelup": { - "version": "4.4.0", - "dev": true, - "license": "MIT", - "dependencies": { - "deferred-leveldown": "~5.3.0", - "level-errors": "~2.0.0", - "level-iterator-stream": "~4.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - }, - "engines": { - "node": ">=6" + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" } }, "node_modules/levn": { @@ -19857,12 +15614,30 @@ "node": ">=8" } }, - "node_modules/lowercase-keys": { - "version": "1.0.1", + "node_modules/log-symbols/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, - "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, "engines": { - "node": ">=0.10.0" + "node": ">=4" + } + }, + "node_modules/log-symbols/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/lru_map": { @@ -19886,11 +15661,6 @@ "dev": true, "license": "ISC" }, - "node_modules/ltgt": { - "version": "2.2.1", - "dev": true, - "license": "MIT" - }, "node_modules/make-error": { "version": "1.3.6", "dev": true, @@ -19903,8 +15673,9 @@ }, "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, - "license": "BSD-3-Clause", "engines": { "node": ">=8.9.0" } @@ -19919,50 +15690,20 @@ "safe-buffer": "^5.1.2" } }, - "node_modules/media-typer": { - "version": "0.3.0", + "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, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/memdown": { - "version": "5.1.0", - "dev": true, - "license": "MIT", "dependencies": { - "abstract-leveldown": "~6.2.1", - "functional-red-black-tree": "~1.0.1", - "immediate": "~3.2.3", - "inherits": "~2.0.1", - "ltgt": "~2.2.0", - "safe-buffer": "~5.2.0" + "abstract-level": "^1.0.0", + "functional-red-black-tree": "^1.0.1", + "module-error": "^1.0.1" }, "engines": { - "node": ">=6" + "node": ">=12" } }, - "node_modules/memdown/node_modules/abstract-leveldown": { - "version": "6.2.3", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/memdown/node_modules/immediate": { - "version": "3.2.3", - "dev": true, - "license": "MIT" - }, "node_modules/memorystream": { "version": "0.3.1", "dev": true, @@ -19970,11 +15711,6 @@ "node": ">= 0.10.0" } }, - "node_modules/merge-descriptors": { - "version": "1.0.1", - "dev": true, - "license": "MIT" - }, "node_modules/merge2": { "version": "1.4.1", "dev": true, @@ -19983,28 +15719,6 @@ "node": ">= 8" } }, - "node_modules/merkle-patricia-tree": { - "version": "4.2.2", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@types/levelup": "^4.3.0", - "ethereumjs-util": "^7.1.2", - "level-mem": "^5.0.1", - "level-ws": "^2.0.0", - "readable-stream": "^3.6.0", - "rlp": "^2.2.4", - "semaphore-async-await": "^1.5.1" - } - }, - "node_modules/methods": { - "version": "1.1.2", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/micromatch": { "version": "4.0.4", "dev": true, @@ -20017,29 +15731,6 @@ "node": ">=8.6" } }, - "node_modules/miller-rabin": { - "version": "4.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.0.0", - "brorand": "^1.0.1" - }, - "bin": { - "miller-rabin": "bin/miller-rabin" - } - }, - "node_modules/mime": { - "version": "1.6.0", - "dev": true, - "license": "MIT", - "bin": { - "mime": "cli.js" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/mime-db": { "version": "1.47.0", "dev": true, @@ -20063,6 +15754,7 @@ "version": "1.0.1", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=4" } @@ -20070,6 +15762,7 @@ "node_modules/min-document": { "version": "2.19.0", "dev": true, + "peer": true, "dependencies": { "dom-walk": "^0.1.0" } @@ -20100,23 +15793,6 @@ "dev": true, "license": "MIT" }, - "node_modules/minipass": { - "version": "2.9.0", - "dev": true, - "license": "ISC", - "dependencies": { - "safe-buffer": "^5.1.2", - "yallist": "^3.0.0" - } - }, - "node_modules/minizlib": { - "version": "1.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "minipass": "^2.9.0" - } - }, "node_modules/mkdirp": { "version": "0.5.5", "dev": true, @@ -20128,17 +15804,6 @@ "mkdirp": "bin/cmd.js" } }, - "node_modules/mkdirp-promise": { - "version": "5.0.1", - "dev": true, - "license": "ISC", - "dependencies": { - "mkdirp": "*" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/mnemonist": { "version": "0.38.5", "dev": true, @@ -20236,6 +15901,21 @@ "node": ">=6" } }, + "node_modules/mocha/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" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, "node_modules/mocha/node_modules/glob": { "version": "7.1.3", "dev": true, @@ -20332,75 +16012,48 @@ "node": ">=6" } }, - "node_modules/mock-fs": { - "version": "4.14.0", + "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, - "license": "MIT" + "engines": { + "node": ">=10" + } }, "node_modules/ms": { "version": "2.1.2", "dev": true, "license": "MIT" }, - "node_modules/multibase": { - "version": "0.6.1", - "dev": true, - "license": "MIT", - "dependencies": { - "base-x": "^3.0.8", - "buffer": "^5.5.0" - } - }, - "node_modules/multicodec": { - "version": "0.5.7", - "dev": true, - "license": "MIT", - "dependencies": { - "varint": "^5.0.0" - } - }, - "node_modules/multihashes": { - "version": "0.4.21", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer": "^5.5.0", - "multibase": "^0.7.0", - "varint": "^5.0.0" - } - }, - "node_modules/multihashes/node_modules/multibase": { - "version": "0.7.0", - "dev": true, - "license": "MIT", - "dependencies": { - "base-x": "^3.0.8", - "buffer": "^5.5.0" - } - }, "node_modules/nan": { "version": "2.15.0", "dev": true, "license": "MIT" }, - "node_modules/nano-json-stream-parser": { - "version": "0.1.2", + "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, - "license": "MIT" + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/napi-macros": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/napi-macros/-/napi-macros-2.0.0.tgz", + "integrity": "sha512-A0xLykHtARfueITVDernsAWdtIMbOJgKgcluwENp3AlsKN/PloyO10HtmoqnFAQAcxPkgZN7wdfPfEd0zNGxbg==", + "dev": true }, "node_modules/natural-compare": { "version": "1.4.0", "dev": true, "license": "MIT" }, - "node_modules/negotiator": { - "version": "0.6.2", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/neo-async": { "version": "2.6.2", "dev": true, @@ -20409,7 +16062,8 @@ "node_modules/next-tick": { "version": "1.0.0", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/nice-try": { "version": "1.0.5", @@ -20455,9 +16109,10 @@ } }, "node_modules/node-gyp-build": { - "version": "4.2.3", + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.5.0.tgz", + "integrity": "sha512-2iGbaQBV+ITgCz76ZEjmhUKAKVf7xfY1sRl4UiKQspfZMH2h06SyhNsnSVy50cwkFQDGLyif6m/6uFXHkOZ6rg==", "dev": true, - "license": "MIT", "bin": { "node-gyp-build": "bin.js", "node-gyp-build-optional": "optional.js", @@ -20510,14 +16165,6 @@ "node": ">=0.10.0" } }, - "node_modules/normalize-url": { - "version": "4.5.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/number-is-nan": { "version": "1.0.1", "dev": true, @@ -20615,21 +16262,11 @@ "version": "2.1.5", "dev": true, "license": "BSD", + "peer": true, "dependencies": { "http-https": "^1.0.0" } }, - "node_modules/on-finished": { - "version": "2.3.0", - "dev": true, - "license": "MIT", - "dependencies": { - "ee-first": "1.1.1" - }, - "engines": { - "node": ">= 0.8" - } - }, "node_modules/once": { "version": "1.4.0", "dev": true, @@ -20688,22 +16325,6 @@ "node": ">=0.10.0" } }, - "node_modules/p-cancelable": { - "version": "1.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/p-finally": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "node_modules/p-limit": { "version": "1.3.0", "dev": true, @@ -20726,15 +16347,19 @@ "node": ">=4" } }, - "node_modules/p-timeout": { - "version": "1.2.1", + "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, - "license": "MIT", "dependencies": { - "p-finally": "^1.0.0" + "aggregate-error": "^3.0.0" }, "engines": { - "node": ">=4" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/p-try": { @@ -20756,18 +16381,6 @@ "node": ">=6" } }, - "node_modules/parse-asn1": { - "version": "5.1.6", - "dev": true, - "license": "ISC", - "dependencies": { - "asn1.js": "^5.2.0", - "browserify-aes": "^1.0.0", - "evp_bytestokey": "^1.0.0", - "pbkdf2": "^3.0.3", - "safe-buffer": "^5.1.1" - } - }, "node_modules/parse-cache-control": { "version": "1.0.1", "dev": true @@ -20775,7 +16388,8 @@ "node_modules/parse-headers": { "version": "2.0.3", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/parse-json": { "version": "2.2.0", @@ -20788,14 +16402,6 @@ "node": ">=0.10.0" } }, - "node_modules/parseurl": { - "version": "1.3.3", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, "node_modules/patch-package": { "version": "6.4.7", "dev": true, @@ -20822,6 +16428,20 @@ "npm": ">5" } }, + "node_modules/patch-package/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/patch-package/node_modules/semver": { "version": "5.7.1", "dev": true, @@ -20838,6 +16458,18 @@ "node": ">=6" } }, + "node_modules/patch-package/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/path-browserify": { "version": "1.0.1", "dev": true, @@ -20872,11 +16504,6 @@ "dev": true, "license": "MIT" }, - "node_modules/path-to-regexp": { - "version": "0.1.7", - "dev": true, - "license": "MIT" - }, "node_modules/path-type": { "version": "1.1.0", "dev": true, @@ -20970,14 +16597,6 @@ "node": ">= 0.8.0" } }, - "node_modules/prepend-http": { - "version": "2.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "node_modules/prettier": { "version": "2.5.0", "dev": true, @@ -21076,6 +16695,7 @@ "version": "0.11.10", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">= 0.6.0" } @@ -21101,50 +16721,11 @@ "asap": "~2.0.6" } }, - "node_modules/proxy-addr": { - "version": "2.0.7", - "dev": true, - "license": "MIT", - "dependencies": { - "forwarded": "0.2.0", - "ipaddr.js": "1.9.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/prr": { - "version": "1.0.1", - "dev": true, - "license": "MIT" - }, "node_modules/psl": { "version": "1.8.0", "dev": true, "license": "MIT" }, - "node_modules/public-encrypt": { - "version": "4.0.3", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.1.0", - "browserify-rsa": "^4.0.0", - "create-hash": "^1.1.0", - "parse-asn1": "^5.0.0", - "randombytes": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "node_modules/pump": { - "version": "3.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, "node_modules/punycode": { "version": "2.1.0", "dev": true, @@ -21171,6 +16752,7 @@ "version": "5.1.1", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "decode-uri-component": "^0.2.0", "object-assign": "^4.1.0", @@ -21214,23 +16796,6 @@ "safe-buffer": "^5.1.0" } }, - "node_modules/randomfill": { - "version": "1.0.4", - "dev": true, - "license": "MIT", - "dependencies": { - "randombytes": "^2.0.5", - "safe-buffer": "^5.1.0" - } - }, - "node_modules/range-parser": { - "version": "1.2.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "node_modules/raw-body": { "version": "2.4.2", "dev": true, @@ -21536,14 +17101,6 @@ "node": ">=4" } }, - "node_modules/responselike": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "lowercase-keys": "^1.0.0" - } - }, "node_modules/reusify": { "version": "1.0.4", "dev": true, @@ -21606,10 +17163,34 @@ "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", - "dev": true, - "license": "(MIT OR Apache-2.0)" + "resolved": "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz", + "integrity": "sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA==", + "dev": true }, "node_modules/safe-buffer": { "version": "5.2.1", @@ -21734,14 +17315,6 @@ "node": ">=10.0.0" } }, - "node_modules/semaphore-async-await": { - "version": "1.5.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4.1" - } - }, "node_modules/semver": { "version": "7.3.5", "dev": true, @@ -21756,74 +17329,13 @@ "node": ">=10" } }, - "node_modules/send": { - "version": "0.17.1", + "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, - "license": "MIT", "dependencies": { - "debug": "2.6.9", - "depd": "~1.1.2", - "destroy": "~1.0.4", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "0.5.2", - "http-errors": "~1.7.2", - "mime": "1.6.0", - "ms": "2.1.1", - "on-finished": "~2.3.0", - "range-parser": "~1.2.1", - "statuses": "~1.5.0" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/send/node_modules/debug": { - "version": "2.6.9", - "dev": true, - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/send/node_modules/debug/node_modules/ms": { - "version": "2.0.0", - "dev": true, - "license": "MIT" - }, - "node_modules/send/node_modules/ms": { - "version": "2.1.1", - "dev": true, - "license": "MIT" - }, - "node_modules/serve-static": { - "version": "1.14.1", - "dev": true, - "license": "MIT", - "dependencies": { - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "parseurl": "~1.3.3", - "send": "0.17.1" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/servify": { - "version": "0.1.12", - "dev": true, - "license": "MIT", - "dependencies": { - "body-parser": "^1.16.0", - "cors": "^2.8.1", - "express": "^4.14.0", - "request": "^2.79.0", - "xhr": "^2.3.3" - }, - "engines": { - "node": ">=6" + "randombytes": "^2.1.0" } }, "node_modules/set-blocking": { @@ -21836,11 +17348,6 @@ "dev": true, "license": "MIT" }, - "node_modules/setprototypeof": { - "version": "1.1.1", - "dev": true, - "license": "ISC" - }, "node_modules/sha.js": { "version": "2.4.11", "dev": true, @@ -21930,12 +17437,14 @@ "url": "https://feross.org/support" } ], - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/simple-get": { "version": "2.8.1", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "decompress-response": "^3.3.0", "once": "^1.3.1", @@ -22025,40 +17534,103 @@ "license": "MIT" }, "node_modules/solidity-coverage": { - "version": "0.7.17", + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.8.2.tgz", + "integrity": "sha512-cv2bWb7lOXPE9/SSleDO6czkFiMHgP4NXPj+iW9W7iEKLBk7Cj0AGBiNmGX3V1totl9wjPrT0gHmABZKZt65rQ==", "dev": true, - "license": "ISC", "dependencies": { - "@solidity-parser/parser": "^0.13.2", - "@truffle/provider": "^0.2.24", + "@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", - "ganache-cli": "^6.12.2", "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.0" + "web3-utils": "^1.3.6" }, "bin": { "solidity-coverage": "plugins/bin.js" + }, + "peerDependencies": { + "hardhat": "^2.11.0" } }, - "node_modules/solidity-coverage/node_modules/@solidity-parser/parser": { - "version": "0.13.2", + "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, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/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, - "license": "MIT", "dependencies": { - "antlr4ts": "^0.5.0-alpha.4" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "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, + "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/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, + "dependencies": { + "ms": "^2.1.1" + } + }, + "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, + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" } }, "node_modules/solidity-coverage/node_modules/fs-extra": { @@ -22074,6 +17646,38 @@ "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" + ], + "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, + "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/globby": { "version": "10.0.2", "dev": true, @@ -22092,6 +17696,116 @@ "node": ">=8" } }, + "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, + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "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, + "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/mocha/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, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "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 + }, + "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, + "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, + "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, + "engines": { + "node": ">=6" + } + }, "node_modules/solidity-coverage/node_modules/pify": { "version": "4.0.1", "dev": true, @@ -22100,6 +17814,39 @@ "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, + "dependencies": { + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "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, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/solidity-coverage/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/source-map": { "version": "0.6.1", "dev": true, @@ -22218,6 +17965,7 @@ "version": "1.1.0", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.0" } @@ -22336,129 +18084,24 @@ } }, "node_modules/supports-color": { - "version": "5.5.0", + "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, - "license": "MIT", "dependencies": { - "has-flag": "^3.0.0" + "has-flag": "^4.0.0" }, "engines": { - "node": ">=4" + "node": ">=8" } }, - "node_modules/swarm-js": { - "version": "0.1.40", + "node_modules/supports-color/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, - "license": "MIT", - "dependencies": { - "bluebird": "^3.5.0", - "buffer": "^5.0.5", - "eth-lib": "^0.1.26", - "fs-extra": "^4.0.2", - "got": "^7.1.0", - "mime-types": "^2.1.16", - "mkdirp-promise": "^5.0.1", - "mock-fs": "^4.1.0", - "setimmediate": "^1.0.5", - "tar": "^4.0.2", - "xhr-request": "^1.0.1" - } - }, - "node_modules/swarm-js/node_modules/eth-lib": { - "version": "0.1.29", - "dev": true, - "license": "MIT", - "dependencies": { - "bn.js": "^4.11.6", - "elliptic": "^6.4.0", - "nano-json-stream-parser": "^0.1.2", - "servify": "^0.1.12", - "ws": "^3.0.0", - "xhr-request-promise": "^0.1.2" - } - }, - "node_modules/swarm-js/node_modules/fs-extra": { - "version": "4.0.3", - "dev": true, - "license": "MIT", - "dependencies": { - "graceful-fs": "^4.1.2", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - } - }, - "node_modules/swarm-js/node_modules/get-stream": { - "version": "3.0.0", - "dev": true, - "license": "MIT", "engines": { - "node": ">=4" - } - }, - "node_modules/swarm-js/node_modules/got": { - "version": "7.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "decompress-response": "^3.2.0", - "duplexer3": "^0.1.4", - "get-stream": "^3.0.0", - "is-plain-obj": "^1.1.0", - "is-retry-allowed": "^1.0.0", - "is-stream": "^1.0.0", - "isurl": "^1.0.0-alpha5", - "lowercase-keys": "^1.0.0", - "p-cancelable": "^0.3.0", - "p-timeout": "^1.1.1", - "safe-buffer": "^5.0.1", - "timed-out": "^4.0.0", - "url-parse-lax": "^1.0.0", - "url-to-options": "^1.0.1" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/swarm-js/node_modules/p-cancelable": { - "version": "0.3.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/swarm-js/node_modules/prepend-http": { - "version": "1.0.4", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/swarm-js/node_modules/safe-buffer": { - "version": "5.1.2", - "dev": true, - "license": "MIT" - }, - "node_modules/swarm-js/node_modules/url-parse-lax": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "prepend-http": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/swarm-js/node_modules/ws": { - "version": "3.3.3", - "dev": true, - "license": "MIT", - "dependencies": { - "async-limiter": "~1.0.0", - "safe-buffer": "~5.1.0", - "ultron": "~1.1.0" + "node": ">=8" } }, "node_modules/sync-request": { @@ -22482,23 +18125,6 @@ "get-port": "^3.1.0" } }, - "node_modules/tar": { - "version": "4.4.19", - "dev": true, - "license": "ISC", - "dependencies": { - "chownr": "^1.1.4", - "fs-minipass": "^1.2.7", - "minipass": "^2.9.0", - "minizlib": "^1.3.3", - "mkdirp": "^0.5.5", - "safe-buffer": "^5.2.1", - "yallist": "^3.1.1" - }, - "engines": { - "node": ">=4.5" - } - }, "node_modules/test-value": { "version": "2.1.0", "dev": true, @@ -22574,6 +18200,7 @@ "version": "4.0.1", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.0" } @@ -22589,14 +18216,6 @@ "node": ">=0.6.0" } }, - "node_modules/to-readable-stream": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, "node_modules/to-regex-range": { "version": "5.0.1", "dev": true, @@ -22608,14 +18227,6 @@ "node": ">=8.0" } }, - "node_modules/toidentifier": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.6" - } - }, "node_modules/tough-cookie": { "version": "2.5.0", "dev": true, @@ -22636,11 +18247,6 @@ "node": ">=6" } }, - "node_modules/true-case-path": { - "version": "2.2.1", - "dev": true, - "license": "Apache-2.0" - }, "node_modules/ts-essentials": { "version": "1.0.4", "dev": true, @@ -22665,6 +18271,32 @@ "ts-generator": "dist/cli/run.js" } }, + "node_modules/ts-generator/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/ts-generator/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/ts-node": { "version": "10.4.0", "dev": true, @@ -22750,18 +18382,21 @@ }, "node_modules/tweetnacl": { "version": "1.0.3", - "dev": true, - "license": "Unlicense" + "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", - "dev": true, - "license": "Unlicense" + "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz", + "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==", + "dev": true }, "node_modules/type": { "version": "1.2.0", "dev": true, - "license": "ISC" + "license": "ISC", + "peer": true }, "node_modules/type-check": { "version": "0.4.0", @@ -22793,18 +18428,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/type-is": { - "version": "1.6.18", - "dev": true, - "license": "MIT", - "dependencies": { - "media-typer": "0.3.0", - "mime-types": "~2.1.24" - }, - "engines": { - "node": ">= 0.6" - } - }, "node_modules/typechain": { "version": "6.0.5", "dev": true, @@ -22856,6 +18479,7 @@ "version": "3.1.5", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "is-typedarray": "^1.0.0" } @@ -22889,11 +18513,6 @@ "node": ">=0.8.0" } }, - "node_modules/ultron": { - "version": "1.1.1", - "dev": true, - "license": "MIT" - }, "node_modules/unbox-primitive": { "version": "1.0.1", "dev": true, @@ -22908,10 +18527,14 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/underscore": { - "version": "1.9.1", + "node_modules/undici": { + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.10.0.tgz", + "integrity": "sha512-c8HsD3IbwmjjbLvoZuRI26TZic+TSEe8FPMLLOkN1AfYRhdjnKBU6yL+IwcSCbdZiX4e5t0lfMDLDCqj4Sq70g==", "dev": true, - "license": "MIT" + "engines": { + "node": ">=12.18" + } }, "node_modules/unfetch": { "version": "4.2.0", @@ -22951,29 +18574,11 @@ "querystring": "0.2.0" } }, - "node_modules/url-parse-lax": { - "version": "3.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "prepend-http": "^2.0.0" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/url-set-query": { "version": "1.0.0", "dev": true, - "license": "MIT" - }, - "node_modules/url-to-options": { - "version": "1.0.1", - "dev": true, "license": "MIT", - "engines": { - "node": ">= 4" - } + "peer": true }, "node_modules/url/node_modules/punycode": { "version": "1.3.2", @@ -22985,6 +18590,7 @@ "dev": true, "hasInstallScript": true, "license": "MIT", + "peer": true, "dependencies": { "node-gyp-build": "^4.2.0" }, @@ -23001,6 +18607,7 @@ "version": "0.12.4", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "inherits": "^2.0.3", "is-arguments": "^1.0.4", @@ -23015,14 +18622,6 @@ "dev": true, "license": "MIT" }, - "node_modules/utils-merge": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4.0" - } - }, "node_modules/uuid": { "version": "3.4.0", "dev": true, @@ -23045,19 +18644,6 @@ "spdx-expression-parse": "^3.0.0" } }, - "node_modules/varint": { - "version": "5.0.2", - "dev": true, - "license": "MIT" - }, - "node_modules/vary": { - "version": "1.1.2", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, "node_modules/verror": { "version": "1.10.0", "dev": true, @@ -23071,47 +18657,11 @@ "extsprintf": "^1.2.0" } }, - "node_modules/web3": { - "version": "1.5.3", - "dev": true, - "hasInstallScript": true, - "license": "LGPL-3.0", - "dependencies": { - "web3-bzz": "1.5.3", - "web3-core": "1.5.3", - "web3-eth": "1.5.3", - "web3-eth-personal": "1.5.3", - "web3-net": "1.5.3", - "web3-shh": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-bzz": { - "version": "1.5.3", - "dev": true, - "hasInstallScript": true, - "license": "LGPL-3.0", - "dependencies": { - "@types/node": "^12.12.6", - "got": "9.6.0", - "swarm-js": "^0.1.40" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-bzz/node_modules/@types/node": { - "version": "12.20.27", - "dev": true, - "license": "MIT" - }, "node_modules/web3-core": { "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "@types/bn.js": "^4.11.5", "@types/node": "^12.12.6", @@ -23129,6 +18679,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "web3-eth-iban": "1.5.3", "web3-utils": "1.5.3" @@ -23141,6 +18692,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -23158,6 +18710,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "@ethereumjs/common": "^2.4.0", "@ethersproject/transactions": "^5.0.0-beta.135", @@ -23174,6 +18727,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -23191,6 +18745,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "eventemitter3": "4.0.4" }, @@ -23202,6 +18757,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "util": "^0.12.0", "web3-core-helpers": "1.5.3", @@ -23217,6 +18773,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "eventemitter3": "4.0.4", "web3-core-helpers": "1.5.3" @@ -23228,229 +18785,14 @@ "node_modules/web3-core/node_modules/@types/node": { "version": "12.20.27", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/web3-core/node_modules/web3-utils": { "version": "1.5.3", "dev": true, "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-eth-accounts": "1.5.3", - "web3-eth-contract": "1.5.3", - "web3-eth-ens": "1.5.3", - "web3-eth-iban": "1.5.3", - "web3-eth-personal": "1.5.3", - "web3-net": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-abi": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "@ethersproject/abi": "5.0.7", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-abi/node_modules/@ethersproject/abi": { - "version": "5.0.7", - "dev": true, - "license": "MIT", - "dependencies": { - "@ethersproject/address": "^5.0.4", - "@ethersproject/bignumber": "^5.0.7", - "@ethersproject/bytes": "^5.0.4", - "@ethersproject/constants": "^5.0.4", - "@ethersproject/hash": "^5.0.4", - "@ethersproject/keccak256": "^5.0.3", - "@ethersproject/logger": "^5.0.5", - "@ethersproject/properties": "^5.0.3", - "@ethersproject/strings": "^5.0.4" - } - }, - "node_modules/web3-eth-abi/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth-accounts": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "@ethereumjs/common": "^2.3.0", - "@ethereumjs/tx": "^3.2.1", - "crypto-browserify": "3.12.0", - "eth-lib": "0.2.8", - "ethereumjs-util": "^7.0.10", - "scrypt-js": "^3.0.1", - "uuid": "3.3.2", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-accounts/node_modules/@types/bn.js": { - "version": "5.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "@types/node": "*" - } - }, - "node_modules/web3-eth-accounts/node_modules/bn.js": { - "version": "5.2.0", - "dev": true, - "license": "MIT" - }, - "node_modules/web3-eth-accounts/node_modules/ethereumjs-util": { - "version": "7.1.1", - "dev": true, - "license": "MPL-2.0", - "dependencies": { - "@types/bn.js": "^5.1.0", - "bn.js": "^5.1.2", - "create-hash": "^1.1.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "0.1.6", - "rlp": "^2.2.4" - }, - "engines": { - "node": ">=10.0.0" - } - }, - "node_modules/web3-eth-accounts/node_modules/uuid": { - "version": "3.3.2", - "dev": true, - "license": "MIT", - "bin": { - "uuid": "bin/uuid" - } - }, - "node_modules/web3-eth-accounts/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth-accounts/node_modules/web3-utils/node_modules/bn.js": { - "version": "4.12.0", - "dev": true, - "license": "MIT" - }, - "node_modules/web3-eth-contract": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "@types/bn.js": "^4.11.5", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-promievent": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-contract/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth-ens": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "content-hash": "^2.5.2", - "eth-ens-namehash": "2.0.8", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-promievent": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-eth-contract": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-ens/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", + "peer": true, "dependencies": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -23468,6 +18810,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "bn.js": "^4.11.9", "web3-utils": "1.5.3" @@ -23480,91 +18823,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth-personal": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "@types/node": "^12.12.6", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-net": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-eth-personal/node_modules/@types/node": { - "version": "12.20.27", - "dev": true, - "license": "MIT" - }, - "node_modules/web3-eth-personal/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-eth/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "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-net": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", - "dependencies": { - "web3-core": "1.5.3", - "web3-core-method": "1.5.3", - "web3-utils": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/web3-net/node_modules/web3-utils": { - "version": "1.5.3", - "dev": true, - "license": "LGPL-3.0", + "peer": true, "dependencies": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -23582,6 +18841,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "web3-core-helpers": "1.5.3", "xhr2-cookies": "1.1.0" @@ -23594,6 +18854,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "oboe": "2.1.5", "web3-core-helpers": "1.5.3" @@ -23606,6 +18867,7 @@ "version": "1.5.3", "dev": true, "license": "LGPL-3.0", + "peer": true, "dependencies": { "eventemitter3": "4.0.4", "web3-core-helpers": "1.5.3", @@ -23615,60 +18877,60 @@ "node": ">=8.0.0" } }, - "node_modules/web3-shh": { - "version": "1.5.3", - "dev": true, - "hasInstallScript": true, - "license": "LGPL-3.0", - "dependencies": { - "web3-core": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-net": "1.5.3" - }, - "engines": { - "node": ">=8.0.0" - } - }, "node_modules/web3-utils": { - "version": "1.3.5", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.8.0.tgz", + "integrity": "sha512-7nUIl7UWpLVka2f09CMbKOSEvorvHnaugIabU4mj7zfMvm0tSByLcEu3eyV9qgS11qxxLuOkzBIwCstTflhmpQ==", "dev": true, - "license": "LGPL-3.0", "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", + "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", - "underscore": "1.9.1", "utf8": "3.0.0" }, "engines": { "node": ">=8.0.0" } }, - "node_modules/web3/node_modules/web3-utils": { - "version": "1.5.3", + "node_modules/web3-utils/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, - "license": "LGPL-3.0", "dependencies": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" + "@types/node": "*" + } + }, + "node_modules/web3-utils/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/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, + "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": ">=8.0.0" + "node": ">=10.0.0" } }, "node_modules/websocket": { "version": "1.0.34", "dev": true, "license": "Apache-2.0", + "peer": true, "dependencies": { "bufferutil": "^4.0.1", "debug": "^2.2.0", @@ -23685,6 +18947,7 @@ "version": "2.6.9", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "ms": "2.0.0" } @@ -23692,7 +18955,8 @@ "node_modules/websocket/node_modules/ms": { "version": "2.0.0", "dev": true, - "license": "MIT" + "license": "MIT", + "peer": true }, "node_modules/which": { "version": "1.3.1", @@ -23729,6 +18993,7 @@ "version": "1.1.7", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "available-typed-arrays": "^1.0.5", "call-bind": "^1.0.2", @@ -23748,6 +19013,7 @@ "version": "1.18.6", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", @@ -23779,6 +19045,7 @@ "version": "1.2.4", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">= 0.4" }, @@ -23790,6 +19057,7 @@ "version": "1.1.4", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -23805,6 +19073,7 @@ "version": "1.0.7", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "has-tostringtag": "^1.0.0" }, @@ -23819,6 +19088,7 @@ "version": "1.11.0", "dev": true, "license": "MIT", + "peer": true, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -23827,6 +19097,7 @@ "version": "4.1.2", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", @@ -23872,6 +19143,12 @@ "dev": true, "license": "MIT" }, + "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": "5.1.0", "dev": true, @@ -23946,6 +19223,7 @@ "version": "2.6.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "global": "~4.4.0", "is-function": "^1.0.1", @@ -23957,6 +19235,7 @@ "version": "1.1.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "buffer-to-arraybuffer": "^0.0.5", "object-assign": "^4.1.1", @@ -23971,6 +19250,7 @@ "version": "0.1.3", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "xhr-request": "^1.1.0" } @@ -23979,6 +19259,7 @@ "version": "1.1.0", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "cookiejar": "^2.1.1" } @@ -23995,6 +19276,7 @@ "version": "4.0.2", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=0.4" } @@ -24008,6 +19290,7 @@ "version": "0.0.6", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.32" } @@ -24151,6 +19434,18 @@ "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": { @@ -24330,13 +19625,6 @@ "version": "2.0.1", "dev": true }, - "debug": { - "version": "4.3.3", - "dev": true, - "requires": { - "ms": "2.1.2" - } - }, "ignore": { "version": "4.0.6", "dev": true @@ -24468,79 +19756,10 @@ "postinstall-postinstall": "^2.1.0" } }, - "@ethereumjs/block": { - "version": "3.6.0", - "dev": true, - "requires": { - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/tx": "^3.4.0", - "ethereumjs-util": "^7.1.3", - "merkle-patricia-tree": "^4.2.2" - }, - "dependencies": { - "@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "requires": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "@ethereumjs/tx": { - "version": "3.4.0", - "dev": true, - "requires": { - "@ethereumjs/common": "^2.6.0", - "ethereumjs-util": "^7.1.3" - } - } - } - }, - "@ethereumjs/blockchain": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethereumjs/block": "^3.6.0", - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/ethash": "^1.1.0", - "debug": "^2.2.0", - "ethereumjs-util": "^7.1.3", - "level-mem": "^5.0.1", - "lru-cache": "^5.1.1", - "semaphore-async-await": "^1.5.1" - }, - "dependencies": { - "@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "requires": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "lru-cache": { - "version": "5.1.1", - "dev": true, - "requires": { - "yallist": "^3.0.2" - } - }, - "ms": { - "version": "2.0.0", - "dev": true - } - } - }, "@ethereumjs/common": { "version": "2.4.0", "dev": true, + "peer": true, "requires": { "crc-32": "^1.2.0", "ethereumjs-util": "^7.1.0" @@ -24549,17 +19768,20 @@ "@types/bn.js": { "version": "5.1.0", "dev": true, + "peer": true, "requires": { "@types/node": "*" } }, "bn.js": { "version": "5.2.0", - "dev": true + "dev": true, + "peer": true }, "ethereumjs-util": { "version": "7.1.0", "dev": true, + "peer": true, "requires": { "@types/bn.js": "^5.1.0", "bn.js": "^5.1.2", @@ -24571,1542 +19793,421 @@ } } }, - "@ethereumjs/ethash": { - "version": "1.1.0", - "dev": true, - "requires": { - "@ethereumjs/block": "^3.5.0", - "@types/levelup": "^4.3.0", - "buffer-xor": "^2.0.1", - "ethereumjs-util": "^7.1.1", - "miller-rabin": "^4.0.0" - }, - "dependencies": { - "buffer-xor": { - "version": "2.0.2", - "dev": true, - "requires": { - "safe-buffer": "^5.1.1" - } - } - } - }, - "@ethereumjs/tx": { - "version": "3.3.0", - "dev": true, - "requires": { - "@ethereumjs/common": "^2.4.0", - "ethereumjs-util": "^7.1.0" - }, - "dependencies": { - "@types/bn.js": { - "version": "5.1.0", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "bn.js": { - "version": "5.2.0", - "dev": true - }, - "ethereumjs-util": { - "version": "7.1.0", - "dev": true, - "requires": { - "@types/bn.js": "^5.1.0", - "bn.js": "^5.1.2", - "create-hash": "^1.1.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "0.1.6", - "rlp": "^2.2.4" - } - } - } - }, - "@ethereumjs/vm": { - "version": "5.6.0", - "dev": true, - "requires": { - "@ethereumjs/block": "^3.6.0", - "@ethereumjs/blockchain": "^5.5.0", - "@ethereumjs/common": "^2.6.0", - "@ethereumjs/tx": "^3.4.0", - "async-eventemitter": "^0.2.4", - "core-js-pure": "^3.0.1", - "debug": "^2.2.0", - "ethereumjs-util": "^7.1.3", - "functional-red-black-tree": "^1.0.1", - "mcl-wasm": "^0.7.1", - "merkle-patricia-tree": "^4.2.2", - "rustbn.js": "~0.2.0" - }, - "dependencies": { - "@ethereumjs/common": { - "version": "2.6.0", - "dev": true, - "requires": { - "crc-32": "^1.2.0", - "ethereumjs-util": "^7.1.3" - } - }, - "@ethereumjs/tx": { - "version": "3.4.0", - "dev": true, - "requires": { - "@ethereumjs/common": "^2.6.0", - "ethereumjs-util": "^7.1.3" - } - }, - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "ms": { - "version": "2.0.0", - "dev": true - } - } - }, "@ethersproject/abi": { - "version": "5.3.1", + "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.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/hash": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.3.0", + "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.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/networks": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/transactions": "^5.3.0", - "@ethersproject/web": "^5.3.0" + "@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.3.0", + "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.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0" + "@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.3.0", + "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.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/rlp": "^5.3.0" + "@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.3.0", + "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.3.0" + "@ethersproject/bytes": "^5.7.0" } }, "@ethersproject/basex": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/properties": "^5.5.0" - }, - "dependencies": { - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - } + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" } }, "@ethersproject/bignumber": { - "version": "5.3.0", + "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.3.0", - "@ethersproject/logger": "^5.3.0", - "bn.js": "^4.11.9" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" + }, + "dependencies": { + "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 + } } }, "@ethersproject/bytes": { - "version": "5.3.0", + "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.3.0" + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/constants": { - "version": "5.3.0", + "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.3.0" + "@ethersproject/bignumber": "^5.7.0" } }, "@ethersproject/contracts": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0" - }, - "dependencies": { - "@ethersproject/abi": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/hash": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } + "@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.3.0", + "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.3.0", - "@ethersproject/address": "^5.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.5.0", + "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.5.0", - "@ethersproject/basex": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/pbkdf2": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/wordlists": "^5.5.0" - }, - "dependencies": { - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } + "@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.5.0", + "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.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/hdnode": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/pbkdf2": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", + "@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" - }, - "dependencies": { - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } } }, "@ethersproject/keccak256": { - "version": "5.3.0", + "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.3.0", - "js-sha3": "0.5.7" - }, - "dependencies": { - "js-sha3": { - "version": "0.5.7", - "dev": true - } + "@ethersproject/bytes": "^5.7.0", + "js-sha3": "0.8.0" } }, "@ethersproject/logger": { - "version": "5.3.0", + "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.3.1", + "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.3.0" + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/pbkdf2": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/sha2": "^5.5.0" - }, - "dependencies": { - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - } + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" } }, "@ethersproject/properties": { - "version": "5.3.0", + "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.3.0" + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/providers": { - "version": "5.5.0", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.1.tgz", + "integrity": "sha512-vZveG/DLyo+wk4Ga1yx6jSEHrLPgmTt+dFv0dv8URpVCRf0jVhalps1jq/emN/oXnMRsC7cQgAF32DcXLL7BPQ==", "dev": true, "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/basex": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/strings": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.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/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": { - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/hash": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } } }, "@ethersproject/random": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/logger": "^5.5.0" - }, - "dependencies": { - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - } + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/rlp": { - "version": "5.3.0", + "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.3.0", - "@ethersproject/logger": "^5.3.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/sha2": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/logger": "^5.5.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", "hash.js": "1.1.7" - }, - "dependencies": { - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - } } }, "@ethersproject/signing-key": { - "version": "5.3.0", + "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.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "bn.js": "^4.11.9", + "@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" + }, + "dependencies": { + "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 + } } }, "@ethersproject/solidity": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/sha2": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - }, - "dependencies": { - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - } + "@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.3.0", + "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.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/logger": "^5.3.0" + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/transactions": { - "version": "5.3.0", + "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.3.0", - "@ethersproject/bignumber": "^5.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/constants": "^5.3.0", - "@ethersproject/keccak256": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/rlp": "^5.3.0", - "@ethersproject/signing-key": "^5.3.0" + "@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.5.0", + "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.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - }, - "dependencies": { - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - } + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" } }, "@ethersproject/wallet": { - "version": "5.5.0", + "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.5.0", - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/hdnode": "^5.5.0", - "@ethersproject/json-wallets": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/random": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/wordlists": "^5.5.0" - }, - "dependencies": { - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/hash": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.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/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.3.0", + "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.3.0", - "@ethersproject/bytes": "^5.3.0", - "@ethersproject/logger": "^5.3.0", - "@ethersproject/properties": "^5.3.0", - "@ethersproject/strings": "^5.3.0" + "@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.5.0", + "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.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - }, - "dependencies": { - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/hash": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } + "@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" } }, "@humanwhocodes/config-array": { @@ -26122,6 +20223,31 @@ "version": "1.2.1", "dev": true }, + "@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" + } + }, + "@noble/hashes": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.2.tgz", + "integrity": "sha512-KYRCASVTv6aeUi1tsF8/vpyR7zpfs3FUzy2Jqm+MU+LmUKhQ0y2FpfwqkCcxSg2ua4GALJd8k2R76WxwZGbQpA==", + "dev": true + }, + "@noble/secp256k1": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.6.3.tgz", + "integrity": "sha512-T04e4iTurVy7I8Sw4+c5OSN9/RkPlo1uKxAomtxQNLq8j1uPAqnsqG1bqvY3Jv7c13gyr6dui0zmh/I3+f/JaQ==", + "dev": true + }, "@nodelib/fs.scandir": { "version": "2.1.4", "dev": true, @@ -26142,6 +20268,258 @@ "fastq": "^1.6.0" } }, + "@nomicfoundation/ethereumjs-block": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-4.0.0.tgz", + "integrity": "sha512-bk8uP8VuexLgyIZAHExH1QEovqx0Lzhc9Ntm63nCRKLHXIZkobaFaeCVwTESV7YkPKUk7NiK11s8ryed4CS9yA==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3" + } + }, + "@nomicfoundation/ethereumjs-blockchain": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-6.0.0.tgz", + "integrity": "sha512-pLFEoea6MWd81QQYSReLlLfH7N9v7lH66JC/NMPN848ySPPQA5renWnE7wPByfQFzNrPBuDDRFFULMDmj1C0xw==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-ethash": "^2.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "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": { + "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" + } + } + } + }, + "@nomicfoundation/ethereumjs-common": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-3.0.0.tgz", + "integrity": "sha512-WS7qSshQfxoZOpHG/XqlHEGRG1zmyjYrvmATvc4c62+gZXgre1ymYP8ZNgx/3FyZY0TWe9OjFlKOfLqmgOeYwA==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "crc-32": "^1.2.0" + } + }, + "@nomicfoundation/ethereumjs-ethash": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-2.0.0.tgz", + "integrity": "sha512-WpDvnRncfDUuXdsAXlI4lXbqUDOA+adYRQaEezIkxqDkc+LDyYDbd/xairmY98GnQzo1zIqsIL6GB5MoMSJDew==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "abstract-level": "^1.0.3", + "bigint-crypto-utils": "^3.0.23", + "ethereum-cryptography": "0.1.3" + } + }, + "@nomicfoundation/ethereumjs-evm": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-1.0.0.tgz", + "integrity": "sha512-hVS6qRo3V1PLKCO210UfcEQHvlG7GqR8iFzp0yyjTg2TmJQizcChKgWo8KFsdMw6AyoLgLhHGHw4HdlP8a4i+Q==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@types/async-eventemitter": "^0.2.1", + "async-eventemitter": "^0.2.4", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + } + }, + "@nomicfoundation/ethereumjs-rlp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-4.0.0.tgz", + "integrity": "sha512-GaSOGk5QbUk4eBP5qFbpXoZoZUj/NrW7MRa0tKY4Ew4c2HAS0GXArEMAamtFrkazp0BO4K5p2ZCG3b2FmbShmw==", + "dev": true + }, + "@nomicfoundation/ethereumjs-statemanager": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-1.0.0.tgz", + "integrity": "sha512-jCtqFjcd2QejtuAMjQzbil/4NHf5aAWxUc+CvS0JclQpl+7M0bxMofR2AJdtz+P3u0ke2euhYREDiE7iSO31vQ==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "functional-red-black-tree": "^1.0.1" + } + }, + "@nomicfoundation/ethereumjs-trie": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-5.0.0.tgz", + "integrity": "sha512-LIj5XdE+s+t6WSuq/ttegJzZ1vliwg6wlb+Y9f4RlBpuK35B9K02bO7xU+E6Rgg9RGptkWd6TVLdedTI4eNc2A==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3", + "readable-stream": "^3.6.0" + } + }, + "@nomicfoundation/ethereumjs-tx": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-4.0.0.tgz", + "integrity": "sha512-Gg3Lir2lNUck43Kp/3x6TfBNwcWC9Z1wYue9Nz3v4xjdcv6oDW9QSMJxqsKw9QEGoBBZ+gqwpW7+F05/rs/g1w==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "ethereum-cryptography": "0.1.3" + } + }, + "@nomicfoundation/ethereumjs-util": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-8.0.0.tgz", + "integrity": "sha512-2emi0NJ/HmTG+CGY58fa+DQuAoroFeSH9gKu9O6JnwTtlzJtgfTixuoOqLEgyyzZVvwfIpRueuePb8TonL1y+A==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-rlp": "^4.0.0-beta.2", + "ethereum-cryptography": "0.1.3" + } + }, + "@nomicfoundation/ethereumjs-vm": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-6.0.0.tgz", + "integrity": "sha512-JMPxvPQ3fzD063Sg3Tp+UdwUkVxMoo1uML6KSzFhMH3hoQi/LMuXBoEHAoW83/vyNS9BxEe6jm6LmT5xdeEJ6w==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-blockchain": "^6.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-evm": "^1.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-statemanager": "^1.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@types/async-eventemitter": "^0.2.1", + "async-eventemitter": "^0.2.4", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "functional-red-black-tree": "^1.0.1", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + } + }, + "@nomicfoundation/solidity-analyzer": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer/-/solidity-analyzer-0.1.0.tgz", + "integrity": "sha512-xGWAiVCGOycvGiP/qrlf9f9eOn7fpNbyJygcB0P21a1MDuVPlKt0Srp7rvtBEutYQ48ouYnRXm33zlRnlTOPHg==", + "dev": true, + "requires": { + "@nomicfoundation/solidity-analyzer-darwin-arm64": "0.1.0", + "@nomicfoundation/solidity-analyzer-darwin-x64": "0.1.0", + "@nomicfoundation/solidity-analyzer-freebsd-x64": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": "0.1.0", + "@nomicfoundation/solidity-analyzer-linux-x64-musl": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": "0.1.0", + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": "0.1.0" + } + }, + "@nomicfoundation/solidity-analyzer-darwin-arm64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-arm64/-/solidity-analyzer-darwin-arm64-0.1.0.tgz", + "integrity": "sha512-vEF3yKuuzfMHsZecHQcnkUrqm8mnTWfJeEVFHpg+cO+le96xQA4lAJYdUan8pXZohQxv1fSReQsn4QGNuBNuCw==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-darwin-x64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-x64/-/solidity-analyzer-darwin-x64-0.1.0.tgz", + "integrity": "sha512-dlHeIg0pTL4dB1l9JDwbi/JG6dHQaU1xpDK+ugYO8eJ1kxx9Dh2isEUtA4d02cQAl22cjOHTvifAk96A+ItEHA==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-freebsd-x64": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-freebsd-x64/-/solidity-analyzer-freebsd-x64-0.1.0.tgz", + "integrity": "sha512-WFCZYMv86WowDA4GiJKnebMQRt3kCcFqHeIomW6NMyqiKqhK1kIZCxSLDYsxqlx396kKLPN1713Q1S8tu68GKg==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-gnu/-/solidity-analyzer-linux-arm64-gnu-0.1.0.tgz", + "integrity": "sha512-DTw6MNQWWlCgc71Pq7CEhEqkb7fZnS7oly13pujs4cMH1sR0JzNk90Mp1zpSCsCs4oKan2ClhMlLKtNat/XRKQ==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-musl/-/solidity-analyzer-linux-arm64-musl-0.1.0.tgz", + "integrity": "sha512-wUpUnR/3GV5Da88MhrxXh/lhb9kxh9V3Jya2NpBEhKDIRCDmtXMSqPMXHZmOR9DfCwCvG6vLFPr/+YrPCnUN0w==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-gnu/-/solidity-analyzer-linux-x64-gnu-0.1.0.tgz", + "integrity": "sha512-lR0AxK1x/MeKQ/3Pt923kPvwigmGX3OxeU5qNtQ9pj9iucgk4PzhbS3ruUeSpYhUxG50jN4RkIGwUMoev5lguw==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-x64-musl": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-musl/-/solidity-analyzer-linux-x64-musl-0.1.0.tgz", + "integrity": "sha512-A1he/8gy/JeBD3FKvmI6WUJrGrI5uWJNr5Xb9WdV+DK0F8msuOqpEByLlnTdLkXMwW7nSl3awvLezOs9xBHJEg==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-arm64-msvc/-/solidity-analyzer-win32-arm64-msvc-0.1.0.tgz", + "integrity": "sha512-7x5SXZ9R9H4SluJZZP8XPN+ju7Mx+XeUMWZw7ZAqkdhP5mK19I4vz3x0zIWygmfE8RT7uQ5xMap0/9NPsO+ykw==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-ia32-msvc/-/solidity-analyzer-win32-ia32-msvc-0.1.0.tgz", + "integrity": "sha512-m7w3xf+hnE774YRXu+2mGV7RiF3QJtUoiYU61FascCkQhX3QMQavh7saH/vzb2jN5D24nT/jwvaHYX/MAM9zUw==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-x64-msvc/-/solidity-analyzer-win32-x64-msvc-0.1.0.tgz", + "integrity": "sha512-xCuybjY0sLJQnJhupiFAXaek2EqF0AP0eBjgzaalPXSNvCEN6ZYHvUzdA50ENDVeSYFXcUsYf3+FsD3XKaeptA==", + "dev": true, + "optional": true + }, "@nomiclabs/hardhat-ethers": { "version": "2.0.2", "dev": true, @@ -26244,6 +20622,33 @@ } } }, + "@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.0", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.0.tgz", + "integrity": "sha512-ftTW3kKX54YXLCxH6BB7oEEoJfoE2pIgw7MINKAs5PsS6nqKPuKk1haTF/EuHmYqG330t5GSrdmtRuHaY1a62Q==", + "dev": true, + "requires": { + "@noble/hashes": "~1.1.1", + "@noble/secp256k1": "~1.6.0", + "@scure/base": "~1.1.0" + } + }, + "@scure/bip39": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.0.tgz", + "integrity": "sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w==", + "dev": true, + "requires": { + "@noble/hashes": "~1.1.1", + "@scure/base": "~1.1.0" + } + }, "@sentry/core": { "version": "5.30.0", "dev": true, @@ -26311,97 +20716,15 @@ "tslib": "^1.9.3" } }, - "@sindresorhus/is": { - "version": "0.14.0", - "dev": true - }, "@solidity-parser/parser": { - "version": "0.14.0", + "version": "0.14.3", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.3.tgz", + "integrity": "sha512-29g2SZ29HtsqA58pLCtopI1P/cPy5/UAzlcAXO6T/CNJimG6yA8kx4NaseMyJULiC+TEs02Y9/yeHzClqoA0hw==", "dev": true, "requires": { "antlr4ts": "^0.5.0-alpha.4" } }, - "@szmarczak/http-timer": { - "version": "1.1.2", - "dev": true, - "requires": { - "defer-to-connect": "^1.0.1" - } - }, - "@truffle/error": { - "version": "0.0.14", - "dev": true - }, - "@truffle/interface-adapter": { - "version": "0.5.7", - "dev": true, - "requires": { - "bn.js": "^5.1.3", - "ethers": "^4.0.32", - "web3": "1.5.3" - }, - "dependencies": { - "bn.js": { - "version": "5.2.0", - "dev": true - }, - "ethers": { - "version": "4.0.49", - "dev": 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" - }, - "dependencies": { - "bn.js": { - "version": "4.12.0", - "dev": true - } - } - }, - "hash.js": { - "version": "1.1.3", - "dev": true, - "requires": { - "inherits": "^2.0.3", - "minimalistic-assert": "^1.0.0" - } - }, - "js-sha3": { - "version": "0.5.7", - "dev": true - }, - "scrypt-js": { - "version": "2.0.4", - "dev": true - }, - "setimmediate": { - "version": "1.0.4", - "dev": true - }, - "uuid": { - "version": "2.0.1", - "dev": true - } - } - }, - "@truffle/provider": { - "version": "0.2.41", - "dev": true, - "requires": { - "@truffle/error": "^0.0.14", - "@truffle/interface-adapter": "^0.5.7", - "web3": "1.5.3" - } - }, "@tsconfig/node10": { "version": "1.0.8", "dev": true @@ -26464,8 +20787,10 @@ } } }, - "@types/abstract-leveldown": { - "version": "5.0.2", + "@types/async-eventemitter": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@types/async-eventemitter/-/async-eventemitter-0.2.1.tgz", + "integrity": "sha512-M2P4Ng26QbAeITiH7w1d7OxtldgfAe0wobpyJzVK/XOb0cUGKU2R4pfAhqcJBXAe2ife5ZOhSv4wk7p+ffURtg==", "dev": true }, "@types/bn.js": { @@ -26505,19 +20830,6 @@ "version": "7.0.9", "dev": true }, - "@types/level-errors": { - "version": "3.0.0", - "dev": true - }, - "@types/levelup": { - "version": "4.3.3", - "dev": true, - "requires": { - "@types/abstract-leveldown": "*", - "@types/level-errors": "*", - "@types/node": "*" - } - }, "@types/lru-cache": { "version": "5.1.1", "dev": true @@ -26590,15 +20902,6 @@ "regexpp": "^3.2.0", "semver": "^7.3.5", "tsutils": "^3.21.0" - }, - "dependencies": { - "debug": { - "version": "4.3.3", - "dev": true, - "requires": { - "ms": "2.1.2" - } - } } }, "@typescript-eslint/experimental-utils": { @@ -26621,15 +20924,6 @@ "@typescript-eslint/types": "5.5.0", "@typescript-eslint/typescript-estree": "5.5.0", "debug": "^4.3.2" - }, - "dependencies": { - "debug": { - "version": "4.3.3", - "dev": true, - "requires": { - "ms": "2.1.2" - } - } } }, "@typescript-eslint/scope-manager": { @@ -26657,13 +20951,6 @@ "tsutils": "^3.21.0" }, "dependencies": { - "debug": { - "version": "4.3.3", - "dev": true, - "requires": { - "ms": "2.1.2" - } - }, "is-glob": { "version": "4.0.3", "dev": true, @@ -26681,6 +20968,12 @@ "eslint-visitor-keys": "^3.0.0" } }, + "@ungap/promise-all-settled": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz", + "integrity": "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==", + "dev": true + }, "@yarnpkg/lockfile": { "version": "1.1.0", "dev": true @@ -26696,23 +20989,31 @@ "event-target-shim": "^5.0.0" } }, - "abstract-leveldown": { - "version": "6.3.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": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - } - }, - "accepts": { - "version": "1.3.7", - "dev": true, - "requires": { - "mime-types": "~2.1.24", - "negotiator": "0.6.2" + "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" + }, + "dependencies": { + "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" + } + } } }, "acorn": { @@ -26747,6 +21048,16 @@ "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", "dev": true, @@ -26842,10 +21153,6 @@ "typical": "^2.6.1" } }, - "array-flatten": { - "version": "1.1.1", - "dev": true - }, "array-union": { "version": "2.1.0", "dev": true @@ -26865,16 +21172,6 @@ "safer-buffer": "~2.1.0" } }, - "asn1.js": { - "version": "5.4.1", - "dev": true, - "requires": { - "bn.js": "^4.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0", - "safer-buffer": "^2.1.0" - } - }, "assert-plus": { "version": "1.0.0", "dev": true @@ -26884,7 +21181,9 @@ "dev": true }, "async": { - "version": "2.6.3", + "version": "2.6.4", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.4.tgz", + "integrity": "sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==", "dev": true, "requires": { "lodash": "^4.17.14" @@ -26892,15 +21191,13 @@ }, "async-eventemitter": { "version": "0.2.4", + "resolved": "https://registry.npmjs.org/async-eventemitter/-/async-eventemitter-0.2.4.tgz", + "integrity": "sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw==", "dev": true, "requires": { "async": "^2.4.0" } }, - "async-limiter": { - "version": "1.0.1", - "dev": true - }, "asynckit": { "version": "0.4.0", "dev": true @@ -26911,7 +21208,8 @@ }, "available-typed-arrays": { "version": "1.0.5", - "dev": true + "dev": true, + "peer": true }, "aws-sign2": { "version": "0.7.0", @@ -26960,6 +21258,21 @@ "version": "1.1.4", "dev": true }, + "bigint-crypto-utils": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.1.6.tgz", + "integrity": "sha512-k5ljSLHx94jQTW3+18KEfxLJR8/XFBHqhfhEGF48qT8p/jL6EdiG7oNOiiIRGMFh2wEP8kaCXZbVd+5dYkngUg==", + "dev": true, + "requires": { + "bigint-mod-arith": "^3.1.0" + } + }, + "bigint-mod-arith": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/bigint-mod-arith/-/bigint-mod-arith-3.1.1.tgz", + "integrity": "sha512-SzFqdncZKXq5uh3oLFZXmzaZEMDsA7ml9l53xKaVGO6/+y26xNwAaTQEg2R+D+d07YduLbKi0dni3YPsR51UDQ==", + "dev": true + }, "bignumber.js": { "version": "9.0.1", "dev": true @@ -26994,64 +21307,6 @@ "version": "4.12.0", "dev": true }, - "body-parser": { - "version": "1.19.0", - "dev": true, - "requires": { - "bytes": "3.1.0", - "content-type": "~1.0.4", - "debug": "2.6.9", - "depd": "~1.1.2", - "http-errors": "1.7.2", - "iconv-lite": "0.4.24", - "on-finished": "~2.3.0", - "qs": "6.7.0", - "raw-body": "2.4.0", - "type-is": "~1.6.17" - }, - "dependencies": { - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "http-errors": { - "version": "1.7.2", - "dev": true, - "requires": { - "depd": "~1.1.2", - "inherits": "2.0.3", - "setprototypeof": "1.1.1", - "statuses": ">= 1.5.0 < 2", - "toidentifier": "1.0.0" - } - }, - "inherits": { - "version": "2.0.3", - "dev": true - }, - "ms": { - "version": "2.0.0", - "dev": true - }, - "qs": { - "version": "6.7.0", - "dev": true - }, - "raw-body": { - "version": "2.4.0", - "dev": true, - "requires": { - "bytes": "3.1.0", - "http-errors": "1.7.2", - "iconv-lite": "0.4.24", - "unpipe": "1.0.0" - } - } - } - }, "brace-expansion": { "version": "1.1.11", "dev": true, @@ -27071,6 +21326,18 @@ "version": "1.1.0", "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", "dev": true @@ -27087,60 +21354,6 @@ "safe-buffer": "^5.0.1" } }, - "browserify-cipher": { - "version": "1.0.1", - "dev": true, - "requires": { - "browserify-aes": "^1.0.4", - "browserify-des": "^1.0.0", - "evp_bytestokey": "^1.0.0" - } - }, - "browserify-des": { - "version": "1.0.2", - "dev": true, - "requires": { - "cipher-base": "^1.0.1", - "des.js": "^1.0.0", - "inherits": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "browserify-rsa": { - "version": "4.1.0", - "dev": true, - "requires": { - "bn.js": "^5.0.0", - "randombytes": "^2.0.1" - }, - "dependencies": { - "bn.js": { - "version": "5.2.0", - "dev": true - } - } - }, - "browserify-sign": { - "version": "4.2.1", - "dev": true, - "requires": { - "bn.js": "^5.1.1", - "browserify-rsa": "^4.0.1", - "create-hash": "^1.2.0", - "create-hmac": "^1.1.7", - "elliptic": "^6.5.3", - "inherits": "^2.0.4", - "parse-asn1": "^5.1.5", - "readable-stream": "^3.6.0", - "safe-buffer": "^5.2.0" - }, - "dependencies": { - "bn.js": { - "version": "5.2.0", - "dev": true - } - } - }, "bs58": { "version": "4.0.1", "dev": true, @@ -27157,21 +21370,14 @@ "safe-buffer": "^5.1.2" } }, - "buffer": { - "version": "5.7.1", - "dev": true, - "requires": { - "base64-js": "^1.3.1", - "ieee754": "^1.1.13" - } - }, "buffer-from": { "version": "1.1.2", "dev": true }, "buffer-to-arraybuffer": { "version": "0.0.5", - "dev": true + "dev": true, + "peer": true }, "buffer-xor": { "version": "1.0.3", @@ -27180,40 +21386,11 @@ "bufferutil": { "version": "4.0.4", "dev": true, + "peer": true, "requires": { "node-gyp-build": "^4.2.0" } }, - "bytes": { - "version": "3.1.0", - "dev": true - }, - "cacheable-request": { - "version": "6.1.0", - "dev": true, - "requires": { - "clone-response": "^1.0.2", - "get-stream": "^5.1.0", - "http-cache-semantics": "^4.0.0", - "keyv": "^3.0.0", - "lowercase-keys": "^2.0.0", - "normalize-url": "^4.1.0", - "responselike": "^1.0.2" - }, - "dependencies": { - "get-stream": { - "version": "5.2.0", - "dev": true, - "requires": { - "pump": "^3.0.0" - } - }, - "lowercase-keys": { - "version": "2.0.0", - "dev": true - } - } - }, "call-bind": { "version": "1.0.2", "dev": true, @@ -27234,6 +21411,12 @@ "version": "0.12.0", "dev": 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": "5.2.0", "dev": true, @@ -27255,12 +21438,39 @@ } }, "chalk": { - "version": "2.4.2", + "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": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "^4.1.0", + "supports-color": "^7.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" + } + }, + "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 + } } }, "charenc": { @@ -27272,7 +21482,9 @@ "dev": true }, "chokidar": { - "version": "3.5.2", + "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", @@ -27285,35 +21497,10 @@ "readdirp": "~3.6.0" } }, - "chownr": { - "version": "1.1.4", - "dev": true - }, "ci-info": { "version": "2.0.0", "dev": true }, - "cids": { - "version": "0.7.5", - "dev": true, - "requires": { - "buffer": "^5.5.0", - "class-is": "^1.1.0", - "multibase": "~0.6.0", - "multicodec": "^1.0.0", - "multihashes": "~0.4.15" - }, - "dependencies": { - "multicodec": { - "version": "1.0.4", - "dev": true, - "requires": { - "buffer": "^5.6.0", - "varint": "^5.0.0" - } - } - } - }, "cipher-base": { "version": "1.0.4", "dev": true, @@ -27322,8 +21509,23 @@ "safe-buffer": "^5.0.1" } }, - "class-is": { - "version": "1.1.0", + "classic-level": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/classic-level/-/classic-level-1.2.0.tgz", + "integrity": "sha512-qw5B31ANxSluWz9xBzklRWTUAJ1SXIdaVKTVS7HcTGKOAmExx65Wo5BUICW+YGORe2FOUaDghoI9ZDxj82QcFg==", + "dev": true, + "requires": { + "abstract-level": "^1.0.2", + "catering": "^2.1.0", + "module-error": "^1.0.1", + "napi-macros": "~2.0.0", + "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": { @@ -27385,13 +21587,6 @@ } } }, - "clone-response": { - "version": "1.0.2", - "dev": true, - "requires": { - "mimic-response": "^1.0.0" - } - }, "code-point-at": { "version": "1.1.0", "dev": true @@ -27468,60 +21663,19 @@ } } }, - "content-disposition": { - "version": "0.5.3", - "dev": true, - "requires": { - "safe-buffer": "5.1.2" - }, - "dependencies": { - "safe-buffer": { - "version": "5.1.2", - "dev": true - } - } - }, - "content-hash": { - "version": "2.5.2", - "dev": true, - "requires": { - "cids": "^0.7.1", - "multicodec": "^0.5.5", - "multihashes": "^0.4.15" - } - }, - "content-type": { - "version": "1.0.4", - "dev": true - }, "cookie": { "version": "0.4.1", "dev": true }, - "cookie-signature": { - "version": "1.0.6", - "dev": true - }, "cookiejar": { "version": "2.1.2", - "dev": true - }, - "core-js-pure": { - "version": "3.19.2", - "dev": true + "dev": true, + "peer": true }, "core-util-is": { "version": "1.0.2", "dev": true }, - "cors": { - "version": "2.8.5", - "dev": true, - "requires": { - "object-assign": "^4", - "vary": "^1" - } - }, "crc-32": { "version": "1.2.0", "dev": true, @@ -27530,14 +21684,6 @@ "printj": "~1.1.0" } }, - "create-ecdh": { - "version": "4.0.4", - "dev": true, - "requires": { - "bn.js": "^4.1.0", - "elliptic": "^6.5.3" - } - }, "create-hash": { "version": "1.2.0", "dev": true, @@ -27586,23 +21732,6 @@ "version": "0.0.2", "dev": true }, - "crypto-browserify": { - "version": "3.12.0", - "dev": true, - "requires": { - "browserify-cipher": "^1.0.0", - "browserify-sign": "^4.0.0", - "create-ecdh": "^4.0.0", - "create-hash": "^1.1.0", - "create-hmac": "^1.1.0", - "diffie-hellman": "^5.0.0", - "inherits": "^2.0.1", - "pbkdf2": "^3.0.3", - "public-encrypt": "^4.0.0", - "randombytes": "^2.0.0", - "randomfill": "^1.0.3" - } - }, "crypto-js": { "version": "4.1.1", "dev": true @@ -27610,6 +21739,7 @@ "d": { "version": "1.0.1", "dev": true, + "peer": true, "requires": { "es5-ext": "^0.10.50", "type": "^1.0.1" @@ -27627,7 +21757,9 @@ "dev": true }, "debug": { - "version": "4.3.1", + "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" @@ -27639,11 +21771,13 @@ }, "decode-uri-component": { "version": "0.2.0", - "dev": true + "dev": true, + "peer": true }, "decompress-response": { "version": "3.3.0", "dev": true, + "peer": true, "requires": { "mimic-response": "^1.0.0" } @@ -27680,31 +21814,6 @@ "node-fetch": "^2.6.0" } }, - "defer-to-connect": { - "version": "1.1.3", - "dev": true - }, - "deferred-leveldown": { - "version": "5.3.0", - "dev": true, - "requires": { - "abstract-leveldown": "~6.2.1", - "inherits": "^2.0.3" - }, - "dependencies": { - "abstract-leveldown": { - "version": "6.2.3", - "dev": true, - "requires": { - "buffer": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - } - } - } - }, "define-properties": { "version": "1.1.3", "dev": true, @@ -27720,18 +21829,6 @@ "version": "1.1.2", "dev": true }, - "des.js": { - "version": "1.0.1", - "dev": true, - "requires": { - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0" - } - }, - "destroy": { - "version": "1.0.4", - "dev": true - }, "detect-port": { "version": "1.3.0", "dev": true, @@ -27757,13 +21854,13 @@ "version": "3.5.0", "dev": true }, - "diffie-hellman": { - "version": "5.0.3", + "difflib": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/difflib/-/difflib-0.2.4.tgz", + "integrity": "sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==", "dev": true, "requires": { - "bn.js": "^4.1.0", - "miller-rabin": "^4.0.0", - "randombytes": "^2.0.0" + "heap": ">= 0.2.0" } }, "dir-glob": { @@ -27788,7 +21885,8 @@ }, "dom-walk": { "version": "0.1.2", - "dev": true + "dev": true, + "peer": true }, "dotenv": { "version": "10.0.0", @@ -27803,10 +21901,6 @@ "create-hmac": "^1.1.4" } }, - "duplexer3": { - "version": "0.1.4", - "dev": true - }, "ecc-jsbn": { "version": "0.1.2", "dev": true, @@ -27815,10 +21909,6 @@ "safer-buffer": "^2.1.0" } }, - "ee-first": { - "version": "1.1.1", - "dev": true - }, "elliptic": { "version": "6.5.4", "dev": true, @@ -27836,27 +21926,6 @@ "version": "7.0.3", "dev": true }, - "encodeurl": { - "version": "1.0.2", - "dev": true - }, - "encoding-down": { - "version": "6.3.0", - "dev": true, - "requires": { - "abstract-leveldown": "^6.2.1", - "inherits": "^2.0.3", - "level-codec": "^9.0.0", - "level-errors": "^2.0.0" - } - }, - "end-of-stream": { - "version": "1.4.4", - "dev": true, - "requires": { - "once": "^1.4.0" - } - }, "enquirer": { "version": "2.3.6", "dev": true, @@ -27868,13 +21937,6 @@ "version": "2.2.1", "dev": true }, - "errno": { - "version": "0.1.8", - "dev": true, - "requires": { - "prr": "~1.0.1" - } - }, "error-ex": { "version": "1.3.2", "dev": true, @@ -27947,6 +22009,7 @@ "es5-ext": { "version": "0.10.53", "dev": true, + "peer": true, "requires": { "es6-iterator": "~2.0.3", "es6-symbol": "~3.1.3", @@ -27956,6 +22019,7 @@ "es6-iterator": { "version": "2.0.3", "dev": true, + "peer": true, "requires": { "d": "1", "es5-ext": "^0.10.35", @@ -27965,13 +22029,16 @@ "es6-symbol": { "version": "3.1.3", "dev": true, + "peer": true, "requires": { "d": "^1.0.1", "ext": "^1.1.2" } }, - "escape-html": { - "version": "1.0.3", + "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": { @@ -28082,36 +22149,10 @@ "v8-compile-cache": "^2.0.3" }, "dependencies": { - "ansi-styles": { - "version": "4.3.0", - "dev": true, - "requires": { - "color-convert": "^2.0.1" - } - }, "argparse": { "version": "2.0.1", "dev": true }, - "chalk": { - "version": "4.1.2", - "dev": true, - "requires": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - } - }, - "color-convert": { - "version": "2.0.1", - "dev": true, - "requires": { - "color-name": "~1.1.4" - } - }, - "color-name": { - "version": "1.1.4", - "dev": true - }, "cross-spawn": { "version": "7.0.3", "dev": true, @@ -28121,13 +22162,6 @@ "which": "^2.0.1" } }, - "debug": { - "version": "4.3.3", - "dev": true, - "requires": { - "ms": "2.1.2" - } - }, "escape-string-regexp": { "version": "4.0.0", "dev": true @@ -28160,10 +22194,6 @@ } } }, - "has-flag": { - "version": "4.0.0", - "dev": true - }, "ignore": { "version": "4.0.6", "dev": true @@ -28190,13 +22220,6 @@ "version": "3.0.0", "dev": true }, - "supports-color": { - "version": "7.2.0", - "dev": true, - "requires": { - "has-flag": "^4.0.0" - } - }, "which": { "version": "2.0.2", "dev": true, @@ -28290,10 +22313,6 @@ "version": "2.0.3", "dev": true }, - "etag": { - "version": "1.8.1", - "dev": true - }, "eth-ens-namehash": { "version": "2.0.8", "dev": true, @@ -28419,37 +22438,13 @@ "eth-lib": { "version": "0.2.8", "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.6", "elliptic": "^6.4.0", "xhr-request-promise": "^0.1.2" } }, - "eth-sig-util": { - "version": "2.5.4", - "dev": true, - "requires": { - "ethereumjs-abi": "0.6.8", - "ethereumjs-util": "^5.1.1", - "tweetnacl": "^1.0.3", - "tweetnacl-util": "^0.15.0" - }, - "dependencies": { - "ethereumjs-util": { - "version": "5.2.1", - "dev": true, - "requires": { - "bn.js": "^4.11.0", - "create-hash": "^1.1.2", - "elliptic": "^6.5.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "^0.1.3", - "rlp": "^2.0.0", - "safe-buffer": "^5.1.1" - } - } - } - }, "ethereum-bloom-filters": { "version": "1.0.9", "dev": true, @@ -28490,263 +22485,65 @@ } }, "ethereumjs-abi": { - "version": "0.6.8", + "version": "git+ssh://git@github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0", "dev": true, + "from": "ethereumjs-abi@^0.6.8", "requires": { "bn.js": "^4.11.8", "ethereumjs-util": "^6.0.0" - }, - "dependencies": { - "ethereumjs-util": { - "version": "6.2.1", - "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" - } - } } }, "ethereumjs-util": { - "version": "7.1.3", + "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": "^5.1.0", - "bn.js": "^5.1.2", + "@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", - "rlp": "^2.2.4" - }, - "dependencies": { - "@types/bn.js": { - "version": "5.1.0", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "bn.js": { - "version": "5.2.0", - "dev": true - } + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" } }, "ethers": { - "version": "5.5.1", + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.1.tgz", + "integrity": "sha512-5krze4dRLITX7FpU8J4WscXqADiKmyeNlylmmDLbS95DaZpBhDe2YSwRQwKXWNyXcox7a3gBgm/MkGXV1O1S/Q==", "dev": true, "requires": { - "@ethersproject/abi": "5.5.0", - "@ethersproject/abstract-provider": "5.5.1", - "@ethersproject/abstract-signer": "5.5.0", - "@ethersproject/address": "5.5.0", - "@ethersproject/base64": "5.5.0", - "@ethersproject/basex": "5.5.0", - "@ethersproject/bignumber": "5.5.0", - "@ethersproject/bytes": "5.5.0", - "@ethersproject/constants": "5.5.0", - "@ethersproject/contracts": "5.5.0", - "@ethersproject/hash": "5.5.0", - "@ethersproject/hdnode": "5.5.0", - "@ethersproject/json-wallets": "5.5.0", - "@ethersproject/keccak256": "5.5.0", - "@ethersproject/logger": "5.5.0", - "@ethersproject/networks": "5.5.0", - "@ethersproject/pbkdf2": "5.5.0", - "@ethersproject/properties": "5.5.0", - "@ethersproject/providers": "5.5.0", - "@ethersproject/random": "5.5.0", - "@ethersproject/rlp": "5.5.0", - "@ethersproject/sha2": "5.5.0", - "@ethersproject/signing-key": "5.5.0", - "@ethersproject/solidity": "5.5.0", - "@ethersproject/strings": "5.5.0", - "@ethersproject/transactions": "5.5.0", - "@ethersproject/units": "5.5.0", - "@ethersproject/wallet": "5.5.0", - "@ethersproject/web": "5.5.0", - "@ethersproject/wordlists": "5.5.0" - }, - "dependencies": { - "@ethersproject/abi": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/hash": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/abstract-provider": { - "version": "5.5.1", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/networks": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/transactions": "^5.5.0", - "@ethersproject/web": "^5.5.0" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-provider": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0" - } - }, - "@ethersproject/address": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/rlp": "^5.5.0" - } - }, - "@ethersproject/base64": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0" - } - }, - "@ethersproject/bignumber": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "bn.js": "^4.11.9" - } - }, - "@ethersproject/bytes": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/constants": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bignumber": "^5.5.0" - } - }, - "@ethersproject/hash": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/abstract-signer": "^5.5.0", - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - }, - "@ethersproject/keccak256": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "js-sha3": "0.8.0" - } - }, - "@ethersproject/logger": { - "version": "5.5.0", - "dev": true - }, - "@ethersproject/networks": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/properties": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/rlp": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/signing-key": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "bn.js": "^4.11.9", - "elliptic": "6.5.4", - "hash.js": "1.1.7" - } - }, - "@ethersproject/strings": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/logger": "^5.5.0" - } - }, - "@ethersproject/transactions": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/address": "^5.5.0", - "@ethersproject/bignumber": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/constants": "^5.5.0", - "@ethersproject/keccak256": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/rlp": "^5.5.0", - "@ethersproject/signing-key": "^5.5.0" - } - }, - "@ethersproject/web": { - "version": "5.5.0", - "dev": true, - "requires": { - "@ethersproject/base64": "^5.5.0", - "@ethersproject/bytes": "^5.5.0", - "@ethersproject/logger": "^5.5.0", - "@ethersproject/properties": "^5.5.0", - "@ethersproject/strings": "^5.5.0" - } - } + "@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.1", + "@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": { @@ -28777,7 +22574,8 @@ }, "eventemitter3": { "version": "4.0.4", - "dev": true + "dev": true, + "peer": true }, "evp_bytestokey": { "version": "1.0.3", @@ -28791,77 +22589,18 @@ "version": "1.0.1", "dev": true }, - "express": { - "version": "4.17.1", - "dev": true, - "requires": { - "accepts": "~1.3.7", - "array-flatten": "1.1.1", - "body-parser": "1.19.0", - "content-disposition": "0.5.3", - "content-type": "~1.0.4", - "cookie": "0.4.0", - "cookie-signature": "1.0.6", - "debug": "2.6.9", - "depd": "~1.1.2", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "~1.1.2", - "fresh": "0.5.2", - "merge-descriptors": "1.0.1", - "methods": "~1.1.2", - "on-finished": "~2.3.0", - "parseurl": "~1.3.3", - "path-to-regexp": "0.1.7", - "proxy-addr": "~2.0.5", - "qs": "6.7.0", - "range-parser": "~1.2.1", - "safe-buffer": "5.1.2", - "send": "0.17.1", - "serve-static": "1.14.1", - "setprototypeof": "1.1.1", - "statuses": "~1.5.0", - "type-is": "~1.6.18", - "utils-merge": "1.0.1", - "vary": "~1.1.2" - }, - "dependencies": { - "cookie": { - "version": "0.4.0", - "dev": true - }, - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "ms": { - "version": "2.0.0", - "dev": true - }, - "qs": { - "version": "6.7.0", - "dev": true - }, - "safe-buffer": { - "version": "5.1.2", - "dev": true - } - } - }, "ext": { "version": "1.6.0", "dev": true, + "peer": true, "requires": { "type": "^2.5.0" }, "dependencies": { "type": { "version": "2.5.0", - "dev": true + "dev": true, + "peer": true } } }, @@ -28930,32 +22669,6 @@ "to-regex-range": "^5.0.1" } }, - "finalhandler": { - "version": "1.1.2", - "dev": true, - "requires": { - "debug": "2.6.9", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "on-finished": "~2.3.0", - "parseurl": "~1.3.3", - "statuses": "~1.5.0", - "unpipe": "~1.0.0" - }, - "dependencies": { - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "ms": { - "version": "2.0.0", - "dev": true - } - } - }, "find-replace": { "version": "1.0.3", "dev": true, @@ -29037,7 +22750,8 @@ }, "foreach": { "version": "2.0.5", - "dev": true + "dev": true, + "peer": true }, "forever-agent": { "version": "0.6.1", @@ -29052,18 +22766,10 @@ "mime-types": "^2.1.12" } }, - "forwarded": { - "version": "0.2.0", - "dev": true - }, "fp-ts": { "version": "1.19.3", "dev": true }, - "fresh": { - "version": "0.5.2", - "dev": true - }, "fs-extra": { "version": "7.0.1", "dev": true, @@ -29073,13 +22779,6 @@ "universalify": "^0.1.0" } }, - "fs-minipass": { - "version": "1.2.7", - "dev": true, - "requires": { - "minipass": "^2.6.0" - } - }, "fs-readdir-recursive": { "version": "1.1.0", "dev": true @@ -29088,6 +22787,13 @@ "version": "1.0.0", "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", "dev": true @@ -29096,779 +22802,6 @@ "version": "1.0.1", "dev": true }, - "ganache-cli": { - "version": "6.12.2", - "dev": true, - "requires": { - "ethereumjs-util": "6.2.1", - "source-map-support": "0.5.12", - "yargs": "13.2.4" - }, - "dependencies": { - "@types/bn.js": { - "version": "4.11.6", - "bundled": true, - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/node": { - "version": "14.11.2", - "bundled": true, - "dev": true - }, - "@types/pbkdf2": { - "version": "3.1.0", - "bundled": true, - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/secp256k1": { - "version": "4.0.1", - "bundled": true, - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "ansi-regex": { - "version": "4.1.0", - "bundled": true, - "dev": true - }, - "ansi-styles": { - "version": "3.2.1", - "bundled": true, - "dev": true, - "requires": { - "color-convert": "^1.9.0" - } - }, - "base-x": { - "version": "3.0.8", - "bundled": true, - "dev": true, - "requires": { - "safe-buffer": "^5.0.1" - } - }, - "blakejs": { - "version": "1.1.0", - "bundled": true, - "dev": true - }, - "bn.js": { - "version": "4.11.9", - "bundled": true, - "dev": true - }, - "brorand": { - "version": "1.1.0", - "bundled": true, - "dev": true - }, - "browserify-aes": { - "version": "1.2.0", - "bundled": true, - "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", - "bundled": true, - "dev": true, - "requires": { - "base-x": "^3.0.2" - } - }, - "bs58check": { - "version": "2.1.2", - "bundled": true, - "dev": true, - "requires": { - "bs58": "^4.0.0", - "create-hash": "^1.1.0", - "safe-buffer": "^5.1.2" - } - }, - "buffer-from": { - "version": "1.1.1", - "bundled": true, - "dev": true - }, - "buffer-xor": { - "version": "1.0.3", - "bundled": true, - "dev": true - }, - "camelcase": { - "version": "5.3.1", - "bundled": true, - "dev": true - }, - "cipher-base": { - "version": "1.0.4", - "bundled": true, - "dev": true, - "requires": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" - } - }, - "cliui": { - "version": "5.0.0", - "bundled": true, - "dev": true, - "requires": { - "string-width": "^3.1.0", - "strip-ansi": "^5.2.0", - "wrap-ansi": "^5.1.0" - } - }, - "color-convert": { - "version": "1.9.3", - "bundled": true, - "dev": true, - "requires": { - "color-name": "1.1.3" - } - }, - "color-name": { - "version": "1.1.3", - "bundled": true, - "dev": true - }, - "create-hash": { - "version": "1.2.0", - "bundled": true, - "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", - "bundled": true, - "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" - } - }, - "cross-spawn": { - "version": "6.0.5", - "bundled": true, - "dev": true, - "requires": { - "nice-try": "^1.0.4", - "path-key": "^2.0.1", - "semver": "^5.5.0", - "shebang-command": "^1.2.0", - "which": "^1.2.9" - } - }, - "decamelize": { - "version": "1.2.0", - "bundled": true, - "dev": true - }, - "elliptic": { - "version": "6.5.3", - "bundled": true, - "dev": true, - "requires": { - "bn.js": "^4.4.0", - "brorand": "^1.0.1", - "hash.js": "^1.0.0", - "hmac-drbg": "^1.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.0" - } - }, - "emoji-regex": { - "version": "7.0.3", - "bundled": true, - "dev": true - }, - "end-of-stream": { - "version": "1.4.4", - "bundled": true, - "dev": true, - "requires": { - "once": "^1.4.0" - } - }, - "ethereum-cryptography": { - "version": "0.1.3", - "bundled": true, - "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" - } - }, - "ethereumjs-util": { - "version": "6.2.1", - "bundled": true, - "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" - } - }, - "ethjs-util": { - "version": "0.1.6", - "bundled": true, - "dev": true, - "requires": { - "is-hex-prefixed": "1.0.0", - "strip-hex-prefix": "1.0.0" - } - }, - "evp_bytestokey": { - "version": "1.0.3", - "bundled": true, - "dev": true, - "requires": { - "md5.js": "^1.3.4", - "safe-buffer": "^5.1.1" - } - }, - "execa": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "requires": { - "cross-spawn": "^6.0.0", - "get-stream": "^4.0.0", - "is-stream": "^1.1.0", - "npm-run-path": "^2.0.0", - "p-finally": "^1.0.0", - "signal-exit": "^3.0.0", - "strip-eof": "^1.0.0" - } - }, - "find-up": { - "version": "3.0.0", - "bundled": true, - "dev": true, - "requires": { - "locate-path": "^3.0.0" - } - }, - "get-caller-file": { - "version": "2.0.5", - "bundled": true, - "dev": true - }, - "get-stream": { - "version": "4.1.0", - "bundled": true, - "dev": true, - "requires": { - "pump": "^3.0.0" - } - }, - "hash-base": { - "version": "3.1.0", - "bundled": true, - "dev": true, - "requires": { - "inherits": "^2.0.4", - "readable-stream": "^3.6.0", - "safe-buffer": "^5.2.0" - } - }, - "hash.js": { - "version": "1.1.7", - "bundled": true, - "dev": true, - "requires": { - "inherits": "^2.0.3", - "minimalistic-assert": "^1.0.1" - } - }, - "hmac-drbg": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "requires": { - "hash.js": "^1.0.3", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.1" - } - }, - "inherits": { - "version": "2.0.4", - "bundled": true, - "dev": true - }, - "invert-kv": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "is-fullwidth-code-point": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "is-hex-prefixed": { - "version": "1.0.0", - "bundled": true, - "dev": true - }, - "is-stream": { - "version": "1.1.0", - "bundled": true, - "dev": true - }, - "isexe": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "keccak": { - "version": "3.0.1", - "bundled": true, - "dev": true, - "requires": { - "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" - } - }, - "lcid": { - "version": "2.0.0", - "bundled": true, - "dev": true, - "requires": { - "invert-kv": "^2.0.0" - } - }, - "locate-path": { - "version": "3.0.0", - "bundled": true, - "dev": true, - "requires": { - "p-locate": "^3.0.0", - "path-exists": "^3.0.0" - } - }, - "map-age-cleaner": { - "version": "0.1.3", - "bundled": true, - "dev": true, - "requires": { - "p-defer": "^1.0.0" - } - }, - "md5.js": { - "version": "1.3.5", - "bundled": true, - "dev": true, - "requires": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "mem": { - "version": "4.3.0", - "bundled": true, - "dev": true, - "requires": { - "map-age-cleaner": "^0.1.1", - "mimic-fn": "^2.0.0", - "p-is-promise": "^2.0.0" - } - }, - "mimic-fn": { - "version": "2.1.0", - "bundled": true, - "dev": true - }, - "minimalistic-assert": { - "version": "1.0.1", - "bundled": true, - "dev": true - }, - "minimalistic-crypto-utils": { - "version": "1.0.1", - "bundled": true, - "dev": true - }, - "nice-try": { - "version": "1.0.5", - "bundled": true, - "dev": true - }, - "node-addon-api": { - "version": "2.0.2", - "bundled": true, - "dev": true - }, - "node-gyp-build": { - "version": "4.2.3", - "bundled": true, - "dev": true - }, - "npm-run-path": { - "version": "2.0.2", - "bundled": true, - "dev": true, - "requires": { - "path-key": "^2.0.0" - } - }, - "once": { - "version": "1.4.0", - "bundled": true, - "dev": true, - "requires": { - "wrappy": "1" - } - }, - "os-locale": { - "version": "3.1.0", - "bundled": true, - "dev": true, - "requires": { - "execa": "^1.0.0", - "lcid": "^2.0.0", - "mem": "^4.0.0" - } - }, - "p-defer": { - "version": "1.0.0", - "bundled": true, - "dev": true - }, - "p-finally": { - "version": "1.0.0", - "bundled": true, - "dev": true - }, - "p-is-promise": { - "version": "2.1.0", - "bundled": true, - "dev": true - }, - "p-limit": { - "version": "2.3.0", - "bundled": true, - "dev": true, - "requires": { - "p-try": "^2.0.0" - } - }, - "p-locate": { - "version": "3.0.0", - "bundled": true, - "dev": true, - "requires": { - "p-limit": "^2.0.0" - } - }, - "p-try": { - "version": "2.2.0", - "bundled": true, - "dev": true - }, - "path-exists": { - "version": "3.0.0", - "bundled": true, - "dev": true - }, - "path-key": { - "version": "2.0.1", - "bundled": true, - "dev": true - }, - "pbkdf2": { - "version": "3.1.1", - "bundled": true, - "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" - } - }, - "pump": { - "version": "3.0.0", - "bundled": true, - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "randombytes": { - "version": "2.1.0", - "bundled": true, - "dev": true, - "requires": { - "safe-buffer": "^5.1.0" - } - }, - "readable-stream": { - "version": "3.6.0", - "bundled": true, - "dev": true, - "requires": { - "inherits": "^2.0.3", - "string_decoder": "^1.1.1", - "util-deprecate": "^1.0.1" - } - }, - "require-directory": { - "version": "2.1.1", - "bundled": true, - "dev": true - }, - "require-main-filename": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "ripemd160": { - "version": "2.0.2", - "bundled": true, - "dev": true, - "requires": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1" - } - }, - "rlp": { - "version": "2.2.6", - "bundled": true, - "dev": true, - "requires": { - "bn.js": "^4.11.1" - } - }, - "safe-buffer": { - "version": "5.2.1", - "bundled": true, - "dev": true - }, - "scrypt-js": { - "version": "3.0.1", - "bundled": true, - "dev": true - }, - "secp256k1": { - "version": "4.0.2", - "bundled": true, - "dev": true, - "requires": { - "elliptic": "^6.5.2", - "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" - } - }, - "semver": { - "version": "5.7.1", - "bundled": true, - "dev": true - }, - "set-blocking": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "setimmediate": { - "version": "1.0.5", - "bundled": true, - "dev": true - }, - "sha.js": { - "version": "2.4.11", - "bundled": true, - "dev": true, - "requires": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" - } - }, - "shebang-command": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "requires": { - "shebang-regex": "^1.0.0" - } - }, - "shebang-regex": { - "version": "1.0.0", - "bundled": true, - "dev": true - }, - "signal-exit": { - "version": "3.0.3", - "bundled": true, - "dev": true - }, - "source-map": { - "version": "0.6.1", - "bundled": true, - "dev": true - }, - "source-map-support": { - "version": "0.5.12", - "bundled": true, - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "source-map": "^0.6.0" - } - }, - "string_decoder": { - "version": "1.3.0", - "bundled": true, - "dev": true, - "requires": { - "safe-buffer": "~5.2.0" - } - }, - "string-width": { - "version": "3.1.0", - "bundled": true, - "dev": 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", - "bundled": true, - "dev": true, - "requires": { - "ansi-regex": "^4.1.0" - } - }, - "strip-eof": { - "version": "1.0.0", - "bundled": true, - "dev": true - }, - "strip-hex-prefix": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "requires": { - "is-hex-prefixed": "1.0.0" - } - }, - "util-deprecate": { - "version": "1.0.2", - "bundled": true, - "dev": true - }, - "which": { - "version": "1.3.1", - "bundled": true, - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, - "which-module": { - "version": "2.0.0", - "bundled": true, - "dev": true - }, - "wrap-ansi": { - "version": "5.1.0", - "bundled": true, - "dev": true, - "requires": { - "ansi-styles": "^3.2.0", - "string-width": "^3.0.0", - "strip-ansi": "^5.0.0" - } - }, - "wrappy": { - "version": "1.0.2", - "bundled": true, - "dev": true - }, - "y18n": { - "version": "4.0.0", - "bundled": true, - "dev": true - }, - "yargs": { - "version": "13.2.4", - "bundled": true, - "dev": true, - "requires": { - "cliui": "^5.0.0", - "find-up": "^3.0.0", - "get-caller-file": "^2.0.1", - "os-locale": "^3.1.0", - "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.0" - } - }, - "yargs-parser": { - "version": "13.1.2", - "bundled": true, - "dev": true, - "requires": { - "camelcase": "^5.0.0", - "decamelize": "^1.2.0" - } - } - } - }, "ganache-core": { "version": "2.13.2", "dev": true, @@ -29921,181 +22854,6 @@ "@ethersproject/strings": ">=5.0.0-beta.130" } }, - "@ethersproject/abstract-provider": { - "version": "5.0.8", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/networks": "^5.0.7", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/transactions": "^5.0.9", - "@ethersproject/web": "^5.0.12" - } - }, - "@ethersproject/abstract-signer": { - "version": "5.0.10", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/abstract-provider": "^5.0.8", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7" - } - }, - "@ethersproject/address": { - "version": "5.0.9", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/rlp": "^5.0.7" - } - }, - "@ethersproject/base64": { - "version": "5.0.7", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9" - } - }, - "@ethersproject/bignumber": { - "version": "5.0.13", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "bn.js": "^4.4.0" - } - }, - "@ethersproject/bytes": { - "version": "5.0.9", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/logger": "^5.0.8" - } - }, - "@ethersproject/constants": { - "version": "5.0.8", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bignumber": "^5.0.13" - } - }, - "@ethersproject/hash": { - "version": "5.0.10", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/abstract-signer": "^5.0.10", - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" - } - }, - "@ethersproject/keccak256": { - "version": "5.0.7", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9", - "js-sha3": "0.5.7" - } - }, - "@ethersproject/logger": { - "version": "5.0.8", - "dev": true, - "optional": true - }, - "@ethersproject/networks": { - "version": "5.0.7", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/logger": "^5.0.8" - } - }, - "@ethersproject/properties": { - "version": "5.0.7", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/logger": "^5.0.8" - } - }, - "@ethersproject/rlp": { - "version": "5.0.7", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8" - } - }, - "@ethersproject/signing-key": { - "version": "5.0.8", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "elliptic": "6.5.3" - } - }, - "@ethersproject/strings": { - "version": "5.0.8", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/logger": "^5.0.8" - } - }, - "@ethersproject/transactions": { - "version": "5.0.9", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/address": "^5.0.9", - "@ethersproject/bignumber": "^5.0.13", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/constants": "^5.0.8", - "@ethersproject/keccak256": "^5.0.7", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/rlp": "^5.0.7", - "@ethersproject/signing-key": "^5.0.8" - } - }, - "@ethersproject/web": { - "version": "5.0.12", - "dev": true, - "optional": true, - "requires": { - "@ethersproject/base64": "^5.0.7", - "@ethersproject/bytes": "^5.0.9", - "@ethersproject/logger": "^5.0.8", - "@ethersproject/properties": "^5.0.7", - "@ethersproject/strings": "^5.0.8" - } - }, "@sindresorhus/is": { "version": "0.14.0", "dev": true, @@ -30230,13 +22988,6 @@ "lodash": "^4.17.11" } }, - "async-eventemitter": { - "version": "0.2.4", - "dev": true, - "requires": { - "async": "^2.4.0" - } - }, "async-limiter": { "version": "1.0.1", "dev": true @@ -32635,14 +25386,6 @@ "setimmediate": "^1.0.5" } }, - "ethereumjs-abi": { - "version": "0.6.8", - "dev": true, - "requires": { - "bn.js": "^4.11.8", - "ethereumjs-util": "^6.0.0" - } - }, "ethereumjs-account": { "version": "3.0.0", "dev": true, @@ -32858,19 +25601,6 @@ "ethereumjs-util": "^6.0.0" } }, - "ethereumjs-util": { - "version": "6.2.1", - "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" - } - }, "ethereumjs-vm": { "version": "4.2.0", "dev": true, @@ -33607,18 +26337,6 @@ "assert-plus": "^1.0.0" } }, - "glob": { - "version": "7.1.3", - "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" - } - }, "global": { "version": "4.4.0", "dev": true, @@ -35228,10 +27946,6 @@ "bn.js": "^4.11.1" } }, - "rustbn.js": { - "version": "0.2.0", - "dev": true - }, "safe-buffer": { "version": "5.2.1", "dev": true @@ -35990,14 +28704,6 @@ "safe-buffer": "^5.0.1" } }, - "tweetnacl": { - "version": "1.0.3", - "dev": true - }, - "tweetnacl-util": { - "version": "0.15.1", - "dev": true - }, "type": { "version": "1.2.0", "dev": true @@ -36486,29 +29192,6 @@ "ethereumjs-util": "^5.1.1" } }, - "ethereumjs-abi": { - "version": "0.6.8", - "dev": true, - "requires": { - "bn.js": "^4.11.8", - "ethereumjs-util": "^6.0.0" - }, - "dependencies": { - "ethereumjs-util": { - "version": "6.2.1", - "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" - } - } - } - }, "ethereumjs-account": { "version": "2.0.5", "dev": true, @@ -36962,13 +29645,6 @@ "version": "3.2.0", "dev": true }, - "get-stream": { - "version": "4.1.0", - "dev": true, - "requires": { - "pump": "^3.0.0" - } - }, "get-symbol-description": { "version": "1.0.0", "dev": true, @@ -36990,10 +29666,34 @@ "requires": { "chalk": "^2.4.2", "node-emoji": "^1.10.0" + }, + "dependencies": { + "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" + } + }, + "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" + } + } } }, "glob": { - "version": "7.1.6", + "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", @@ -37014,6 +29714,7 @@ "global": { "version": "4.4.0", "dev": true, + "peer": true, "requires": { "min-document": "^2.19.0", "process": "^0.11.10" @@ -37054,23 +29755,6 @@ "slash": "^3.0.0" } }, - "got": { - "version": "9.6.0", - "dev": true, - "requires": { - "@sindresorhus/is": "^0.14.0", - "@szmarczak/http-timer": "^1.1.2", - "cacheable-request": "^6.0.0", - "decompress-response": "^3.3.0", - "duplexer3": "^0.1.4", - "get-stream": "^4.1.0", - "lowercase-keys": "^1.0.1", - "mimic-response": "^1.0.1", - "p-cancelable": "^1.0.0", - "to-readable-stream": "^1.0.0", - "url-parse-lax": "^3.0.0" - } - }, "graceful-fs": { "version": "4.2.6", "dev": true @@ -37103,21 +29787,30 @@ } }, "hardhat": { - "version": "2.7.0", + "version": "2.12.0", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.12.0.tgz", + "integrity": "sha512-mNJFbVG479HwOzxiaLxobyvED2M1aEAuPPYhEo1+88yicMDSTrU2JIS7vV+V0GSNQKaDoiHCmV6bcKjiljT/dQ==", "dev": true, "requires": { - "@ethereumjs/block": "^3.4.0", - "@ethereumjs/blockchain": "^5.4.0", - "@ethereumjs/common": "^2.4.0", - "@ethereumjs/tx": "^3.3.0", - "@ethereumjs/vm": "^5.5.2", "@ethersproject/abi": "^5.1.2", + "@metamask/eth-sig-util": "^4.0.0", + "@nomicfoundation/ethereumjs-block": "^4.0.0", + "@nomicfoundation/ethereumjs-blockchain": "^6.0.0", + "@nomicfoundation/ethereumjs-common": "^3.0.0", + "@nomicfoundation/ethereumjs-evm": "^1.0.0", + "@nomicfoundation/ethereumjs-rlp": "^4.0.0", + "@nomicfoundation/ethereumjs-statemanager": "^1.0.0", + "@nomicfoundation/ethereumjs-trie": "^5.0.0", + "@nomicfoundation/ethereumjs-tx": "^4.0.0", + "@nomicfoundation/ethereumjs-util": "^8.0.0", + "@nomicfoundation/ethereumjs-vm": "^6.0.0", + "@nomicfoundation/solidity-analyzer": "^0.1.0", "@sentry/node": "^5.18.1", - "@solidity-parser/parser": "^0.14.0", "@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", @@ -37125,32 +29818,28 @@ "debug": "^4.1.1", "enquirer": "^2.3.0", "env-paths": "^2.2.0", - "eth-sig-util": "^2.5.2", - "ethereum-cryptography": "^0.1.2", + "ethereum-cryptography": "^1.0.3", "ethereumjs-abi": "^0.6.8", - "ethereumjs-util": "^7.1.0", "find-up": "^2.1.0", "fp-ts": "1.19.3", "fs-extra": "^7.0.1", - "glob": "^7.1.3", - "https-proxy-agent": "^5.0.0", + "glob": "7.2.0", "immutable": "^4.0.0-rc.12", "io-ts": "1.10.4", + "keccak": "^3.0.2", "lodash": "^4.17.11", - "merkle-patricia-tree": "^4.2.0", "mnemonist": "^0.38.0", - "mocha": "^7.1.2", - "node-fetch": "^2.6.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", - "slash": "^3.0.0", "solc": "0.7.3", "source-map-support": "^0.5.13", "stacktrace-parser": "^0.1.10", - "true-case-path": "^2.2.1", "tsort": "0.0.1", + "undici": "^5.4.0", "uuid": "^8.3.2", "ws": "^7.4.6" }, @@ -37162,13 +29851,366 @@ "@types/node": "*" } }, + "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 + }, + "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" + } + }, + "camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true + }, + "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" + } + }, + "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": "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 + }, + "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 + }, + "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 + }, + "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 + }, + "ethereum-cryptography": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.1.2.tgz", + "integrity": "sha512-XDSJlg4BD+hq9N2FjvotwUET9Tfxpxc3kWGE2AqUG5vcbeunnbImVk3cj6e/xT3phdW21mE8R5IugU4fspQDcQ==", + "dev": true, + "requires": { + "@noble/hashes": "1.1.2", + "@noble/secp256k1": "1.6.3", + "@scure/bip32": "1.1.0", + "@scure/bip39": "1.1.0" + } + }, + "flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "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-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 + }, + "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" + } + }, + "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" + } + }, + "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" + } + }, + "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" + } + } + } + }, + "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" + } + }, + "mocha": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.0.0.tgz", + "integrity": "sha512-0Wl+elVUD43Y0BqPZBzZt8Tnkw9CMUdNYnUsTfOM1vuhJVZL+kiesFYsqwBkEEuEixaiPe5ZQdqDgX2jddhmoA==", + "dev": true, + "requires": { + "@ungap/promise-all-settled": "1.1.2", + "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": { + "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 + }, + "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" + } + } + } + }, + "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 + }, "semver": { "version": "6.3.0", "dev": 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" + } + }, + "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" + } + }, "uuid": { "version": "8.3.2", "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" + } + } + } + }, + "y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "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" + } } } }, @@ -37199,6 +30241,15 @@ "dev": true, "requires": {} }, + "hardhat-tracer": { + "version": "1.1.0-rc.6", + "resolved": "https://registry.npmjs.org/hardhat-tracer/-/hardhat-tracer-1.1.0-rc.6.tgz", + "integrity": "sha512-u1d8YpyYBCj/7xVMPDxsx+H1gBaothk/XNLeTYuEmxC6WmVMEwVjpdnmTYZiRQ2ntUfwSIjwKhDkLOqewBqaQA==", + "dev": true, + "requires": { + "ethers": "^5.6.1" + } + }, "has": { "version": "1.0.3", "dev": true, @@ -37214,21 +30265,10 @@ "version": "3.0.0", "dev": true }, - "has-symbol-support-x": { - "version": "1.4.2", - "dev": true - }, "has-symbols": { "version": "1.0.2", "dev": true }, - "has-to-string-tag-x": { - "version": "1.4.1", - "dev": true, - "requires": { - "has-symbol-support-x": "^1.4.1" - } - }, "has-tostringtag": { "version": "1.0.0", "dev": true, @@ -37268,6 +30308,12 @@ "version": "1.2.0", "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 + }, "hmac-drbg": { "version": "1.0.1", "dev": true, @@ -37291,24 +30337,10 @@ "parse-cache-control": "^1.0.1" } }, - "http-cache-semantics": { - "version": "4.1.0", - "dev": true - }, - "http-errors": { - "version": "1.7.3", - "dev": true, - "requires": { - "depd": "~1.1.2", - "inherits": "2.0.4", - "setprototypeof": "1.1.1", - "statuses": ">= 1.5.0 < 2", - "toidentifier": "1.0.0" - } - }, "http-https": { "version": "1.0.0", - "dev": true + "dev": true, + "peer": true }, "http-response-object": { "version": "3.0.2", @@ -37366,10 +30398,6 @@ "version": "5.1.8", "dev": true }, - "immediate": { - "version": "3.3.0", - "dev": true - }, "immutable": { "version": "4.0.0", "dev": true @@ -37386,6 +30414,12 @@ "version": "0.1.4", "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", "dev": true, @@ -37426,13 +30460,10 @@ "fp-ts": "^1.0.0" } }, - "ipaddr.js": { - "version": "1.9.1", - "dev": true - }, "is-arguments": { "version": "1.1.1", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -37493,11 +30524,13 @@ }, "is-function": { "version": "1.0.2", - "dev": true + "dev": true, + "peer": true }, "is-generator-function": { "version": "1.0.10", "dev": true, + "peer": true, "requires": { "has-tostringtag": "^1.0.0" } @@ -37525,14 +30558,6 @@ "version": "1.0.4", "dev": true }, - "is-object": { - "version": "1.0.2", - "dev": true - }, - "is-plain-obj": { - "version": "1.1.0", - "dev": true - }, "is-regex": { "version": "1.1.4", "dev": true, @@ -37541,18 +30566,10 @@ "has-tostringtag": "^1.0.0" } }, - "is-retry-allowed": { - "version": "1.2.0", - "dev": true - }, "is-shared-array-buffer": { "version": "1.0.1", "dev": true }, - "is-stream": { - "version": "1.1.0", - "dev": true - }, "is-string": { "version": "1.0.5", "dev": true @@ -37567,6 +30584,7 @@ "is-typed-array": { "version": "1.1.8", "dev": true, + "peer": true, "requires": { "available-typed-arrays": "^1.0.5", "call-bind": "^1.0.2", @@ -37578,6 +30596,7 @@ "es-abstract": { "version": "1.18.6", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", @@ -37601,11 +30620,13 @@ }, "is-callable": { "version": "1.2.4", - "dev": true + "dev": true, + "peer": true }, "is-regex": { "version": "1.1.4", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -37614,17 +30635,20 @@ "is-string": { "version": "1.0.7", "dev": true, + "peer": true, "requires": { "has-tostringtag": "^1.0.0" } }, "object-inspect": { "version": "1.11.0", - "dev": true + "dev": true, + "peer": true }, "object.assign": { "version": "4.1.2", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", @@ -37638,6 +30662,12 @@ "version": "1.0.0", "dev": 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-url": { "version": "1.2.4", "dev": true @@ -37680,14 +30710,6 @@ "version": "0.1.2", "dev": true }, - "isurl": { - "version": "1.0.0", - "dev": true, - "requires": { - "has-to-string-tag-x": "^1.2.0", - "is-object": "^1.0.1" - } - }, "js-cookie": { "version": "2.2.1", "dev": true @@ -37708,10 +30730,6 @@ "version": "0.1.1", "dev": true }, - "json-buffer": { - "version": "3.0.0", - "dev": true - }, "json-schema": { "version": "0.2.3", "dev": true @@ -37750,18 +30768,14 @@ } }, "keccak": { - "version": "3.0.1", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.2.tgz", + "integrity": "sha512-PyKKjkH53wDMLGrvmRGSNWgmSxZOUqbnXwKL9tmgbFYA1iAYqW21kfR7mZXV0MlESiefxQQE9X9fTa3X+2MPDQ==", "dev": true, "requires": { "node-addon-api": "^2.0.0", - "node-gyp-build": "^4.2.0" - } - }, - "keyv": { - "version": "3.1.0", - "dev": true, - "requires": { - "json-buffer": "3.0.0" + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" } }, "kind-of": { @@ -37789,74 +30803,42 @@ "invert-kv": "^1.0.0" } }, - "level-codec": { - "version": "9.0.2", + "level": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/level/-/level-8.0.0.tgz", + "integrity": "sha512-ypf0jjAk2BWI33yzEaaotpq7fkOPALKAgDBxggO6Q9HGX2MRXn0wbP1Jn/tJv1gtL867+YOjOB49WaUF3UoJNQ==", "dev": true, "requires": { - "buffer": "^5.6.0" - } - }, - "level-concat-iterator": { - "version": "2.0.1", - "dev": true - }, - "level-errors": { - "version": "2.0.1", - "dev": true, - "requires": { - "errno": "~0.1.1" - } - }, - "level-iterator-stream": { - "version": "4.0.2", - "dev": true, - "requires": { - "inherits": "^2.0.4", - "readable-stream": "^3.4.0", - "xtend": "^4.0.2" - } - }, - "level-mem": { - "version": "5.0.1", - "dev": true, - "requires": { - "level-packager": "^5.0.3", - "memdown": "^5.0.0" - } - }, - "level-packager": { - "version": "5.1.1", - "dev": true, - "requires": { - "encoding-down": "^6.3.0", - "levelup": "^4.3.2" + "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": { - "xtend": "^4.0.2" - } - }, - "level-ws": { - "version": "2.0.0", - "dev": true, - "requires": { - "inherits": "^2.0.3", - "readable-stream": "^3.1.0", - "xtend": "^4.0.1" - } - }, - "levelup": { - "version": "4.4.0", - "dev": true, - "requires": { - "deferred-leveldown": "~5.3.0", - "level-errors": "~2.0.0", - "level-iterator-stream": "~4.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" + "buffer": "^6.0.3", + "module-error": "^1.0.1" + }, + "dependencies": { + "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" + } + } } }, "levn": { @@ -37903,12 +30885,30 @@ "dev": true, "requires": { "chalk": "^2.4.2" + }, + "dependencies": { + "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" + } + }, + "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" + } + } } }, - "lowercase-keys": { - "version": "1.0.1", - "dev": true - }, "lru_map": { "version": "0.3.3", "dev": true @@ -37926,10 +30926,6 @@ } } }, - "ltgt": { - "version": "2.2.1", - "dev": true - }, "make-error": { "version": "1.3.6", "dev": true @@ -37940,6 +30936,8 @@ }, "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": { @@ -37951,68 +30949,25 @@ "safe-buffer": "^5.1.2" } }, - "media-typer": { - "version": "0.3.0", - "dev": true - }, - "memdown": { - "version": "5.1.0", + "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-leveldown": "~6.2.1", - "functional-red-black-tree": "~1.0.1", - "immediate": "~3.2.3", - "inherits": "~2.0.1", - "ltgt": "~2.2.0", - "safe-buffer": "~5.2.0" - }, - "dependencies": { - "abstract-leveldown": { - "version": "6.2.3", - "dev": true, - "requires": { - "buffer": "^5.5.0", - "immediate": "^3.2.3", - "level-concat-iterator": "~2.0.0", - "level-supports": "~1.0.0", - "xtend": "~4.0.0" - } - }, - "immediate": { - "version": "3.2.3", - "dev": true - } + "abstract-level": "^1.0.0", + "functional-red-black-tree": "^1.0.1", + "module-error": "^1.0.1" } }, "memorystream": { "version": "0.3.1", "dev": true }, - "merge-descriptors": { - "version": "1.0.1", - "dev": true - }, "merge2": { "version": "1.4.1", "dev": true }, - "merkle-patricia-tree": { - "version": "4.2.2", - "dev": true, - "requires": { - "@types/levelup": "^4.3.0", - "ethereumjs-util": "^7.1.2", - "level-mem": "^5.0.1", - "level-ws": "^2.0.0", - "readable-stream": "^3.6.0", - "rlp": "^2.2.4", - "semaphore-async-await": "^1.5.1" - } - }, - "methods": { - "version": "1.1.2", - "dev": true - }, "micromatch": { "version": "4.0.4", "dev": true, @@ -38021,18 +30976,6 @@ "picomatch": "^2.2.3" } }, - "miller-rabin": { - "version": "4.0.1", - "dev": true, - "requires": { - "bn.js": "^4.0.0", - "brorand": "^1.0.1" - } - }, - "mime": { - "version": "1.6.0", - "dev": true - }, "mime-db": { "version": "1.47.0", "dev": true @@ -38046,11 +30989,13 @@ }, "mimic-response": { "version": "1.0.1", - "dev": true + "dev": true, + "peer": true }, "min-document": { "version": "2.19.0", "dev": true, + "peer": true, "requires": { "dom-walk": "^0.1.0" } @@ -38074,21 +31019,6 @@ "version": "1.2.5", "dev": true }, - "minipass": { - "version": "2.9.0", - "dev": true, - "requires": { - "safe-buffer": "^5.1.2", - "yallist": "^3.0.0" - } - }, - "minizlib": { - "version": "1.3.3", - "dev": true, - "requires": { - "minipass": "^2.9.0" - } - }, "mkdirp": { "version": "0.5.5", "dev": true, @@ -38096,13 +31026,6 @@ "minimist": "^1.2.5" } }, - "mkdirp-promise": { - "version": "5.0.1", - "dev": true, - "requires": { - "mkdirp": "*" - } - }, "mnemonist": { "version": "0.38.5", "dev": true, @@ -38172,6 +31095,13 @@ "locate-path": "^3.0.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 + }, "glob": { "version": "7.1.3", "dev": true, @@ -38234,71 +31164,44 @@ } } }, - "mock-fs": { - "version": "4.14.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", "dev": true }, - "multibase": { - "version": "0.6.1", - "dev": true, - "requires": { - "base-x": "^3.0.8", - "buffer": "^5.5.0" - } - }, - "multicodec": { - "version": "0.5.7", - "dev": true, - "requires": { - "varint": "^5.0.0" - } - }, - "multihashes": { - "version": "0.4.21", - "dev": true, - "requires": { - "buffer": "^5.5.0", - "multibase": "^0.7.0", - "varint": "^5.0.0" - }, - "dependencies": { - "multibase": { - "version": "0.7.0", - "dev": true, - "requires": { - "base-x": "^3.0.8", - "buffer": "^5.5.0" - } - } - } - }, "nan": { "version": "2.15.0", "dev": true }, - "nano-json-stream-parser": { - "version": "0.1.2", + "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.0.0", + "resolved": "https://registry.npmjs.org/napi-macros/-/napi-macros-2.0.0.tgz", + "integrity": "sha512-A0xLykHtARfueITVDernsAWdtIMbOJgKgcluwENp3AlsKN/PloyO10HtmoqnFAQAcxPkgZN7wdfPfEd0zNGxbg==", "dev": true }, "natural-compare": { "version": "1.4.0", "dev": true }, - "negotiator": { - "version": "0.6.2", - "dev": true - }, "neo-async": { "version": "2.6.2", "dev": true }, "next-tick": { "version": "1.0.0", - "dev": true + "dev": true, + "peer": true }, "nice-try": { "version": "1.0.5", @@ -38334,7 +31237,9 @@ "dev": true }, "node-gyp-build": { - "version": "4.2.3", + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.5.0.tgz", + "integrity": "sha512-2iGbaQBV+ITgCz76ZEjmhUKAKVf7xfY1sRl4UiKQspfZMH2h06SyhNsnSVy50cwkFQDGLyif6m/6uFXHkOZ6rg==", "dev": true }, "nofilter": { @@ -38368,10 +31273,6 @@ "version": "3.0.0", "dev": true }, - "normalize-url": { - "version": "4.5.1", - "dev": true - }, "number-is-nan": { "version": "1.0.1", "dev": true @@ -38432,17 +31333,11 @@ "oboe": { "version": "2.1.5", "dev": true, + "peer": true, "requires": { "http-https": "^1.0.0" } }, - "on-finished": { - "version": "2.3.0", - "dev": true, - "requires": { - "ee-first": "1.1.1" - } - }, "once": { "version": "1.4.0", "dev": true, @@ -38481,14 +31376,6 @@ "version": "1.0.2", "dev": true }, - "p-cancelable": { - "version": "1.1.0", - "dev": true - }, - "p-finally": { - "version": "1.0.0", - "dev": true - }, "p-limit": { "version": "1.3.0", "dev": true, @@ -38503,11 +31390,13 @@ "p-limit": "^1.1.0" } }, - "p-timeout": { - "version": "1.2.1", + "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": { - "p-finally": "^1.0.0" + "aggregate-error": "^3.0.0" } }, "p-try": { @@ -38521,24 +31410,14 @@ "callsites": "^3.0.0" } }, - "parse-asn1": { - "version": "5.1.6", - "dev": true, - "requires": { - "asn1.js": "^5.2.0", - "browserify-aes": "^1.0.0", - "evp_bytestokey": "^1.0.0", - "pbkdf2": "^3.0.3", - "safe-buffer": "^5.1.1" - } - }, "parse-cache-control": { "version": "1.0.1", "dev": true }, "parse-headers": { "version": "2.0.3", - "dev": true + "dev": true, + "peer": true }, "parse-json": { "version": "2.2.0", @@ -38547,10 +31426,6 @@ "error-ex": "^1.2.0" } }, - "parseurl": { - "version": "1.3.3", - "dev": true - }, "patch-package": { "version": "6.4.7", "dev": true, @@ -38570,6 +31445,17 @@ "tmp": "^0.0.33" }, "dependencies": { + "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" + } + }, "semver": { "version": "5.7.1", "dev": true @@ -38577,6 +31463,15 @@ "slash": { "version": "2.0.0", "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" + } } } }, @@ -38600,10 +31495,6 @@ "version": "1.0.6", "dev": true }, - "path-to-regexp": { - "version": "0.1.7", - "dev": true - }, "path-type": { "version": "1.1.0", "dev": true, @@ -38659,10 +31550,6 @@ "version": "1.2.1", "dev": true }, - "prepend-http": { - "version": "2.0.0", - "dev": true - }, "prettier": { "version": "2.5.0", "dev": true @@ -38721,7 +31608,8 @@ }, "process": { "version": "0.11.10", - "dev": true + "dev": true, + "peer": true }, "process-nextick-args": { "version": "2.0.1", @@ -38738,42 +31626,10 @@ "asap": "~2.0.6" } }, - "proxy-addr": { - "version": "2.0.7", - "dev": true, - "requires": { - "forwarded": "0.2.0", - "ipaddr.js": "1.9.1" - } - }, - "prr": { - "version": "1.0.1", - "dev": true - }, "psl": { "version": "1.8.0", "dev": true }, - "public-encrypt": { - "version": "4.0.3", - "dev": true, - "requires": { - "bn.js": "^4.1.0", - "browserify-rsa": "^4.0.0", - "create-hash": "^1.1.0", - "parse-asn1": "^5.0.0", - "randombytes": "^2.0.1", - "safe-buffer": "^5.1.2" - } - }, - "pump": { - "version": "3.0.0", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, "punycode": { "version": "2.1.0", "dev": true @@ -38788,6 +31644,7 @@ "query-string": { "version": "5.1.1", "dev": true, + "peer": true, "requires": { "decode-uri-component": "^0.2.0", "object-assign": "^4.1.0", @@ -38809,18 +31666,6 @@ "safe-buffer": "^5.1.0" } }, - "randomfill": { - "version": "1.0.4", - "dev": true, - "requires": { - "randombytes": "^2.0.5", - "safe-buffer": "^5.1.0" - } - }, - "range-parser": { - "version": "1.2.1", - "dev": true - }, "raw-body": { "version": "2.4.2", "dev": true, @@ -39024,13 +31869,6 @@ "version": "4.0.0", "dev": true }, - "responselike": { - "version": "1.0.2", - "dev": true, - "requires": { - "lowercase-keys": "^1.0.0" - } - }, "reusify": { "version": "1.0.4", "dev": true @@ -39064,8 +31902,19 @@ "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-buffer": { @@ -39145,10 +31994,6 @@ "node-gyp-build": "^4.2.0" } }, - "semaphore-async-await": { - "version": "1.5.1", - "dev": true - }, "semver": { "version": "7.3.5", "dev": true, @@ -39156,63 +32001,13 @@ "lru-cache": "^6.0.0" } }, - "send": { - "version": "0.17.1", + "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": { - "debug": "2.6.9", - "depd": "~1.1.2", - "destroy": "~1.0.4", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "0.5.2", - "http-errors": "~1.7.2", - "mime": "1.6.0", - "ms": "2.1.1", - "on-finished": "~2.3.0", - "range-parser": "~1.2.1", - "statuses": "~1.5.0" - }, - "dependencies": { - "debug": { - "version": "2.6.9", - "dev": true, - "requires": { - "ms": "2.0.0" - }, - "dependencies": { - "ms": { - "version": "2.0.0", - "dev": true - } - } - }, - "ms": { - "version": "2.1.1", - "dev": true - } - } - }, - "serve-static": { - "version": "1.14.1", - "dev": true, - "requires": { - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "parseurl": "~1.3.3", - "send": "0.17.1" - } - }, - "servify": { - "version": "0.1.12", - "dev": true, - "requires": { - "body-parser": "^1.16.0", - "cors": "^2.8.1", - "express": "^4.14.0", - "request": "^2.79.0", - "xhr": "^2.3.3" + "randombytes": "^2.1.0" } }, "set-blocking": { @@ -39223,10 +32018,6 @@ "version": "1.0.5", "dev": true }, - "setprototypeof": { - "version": "1.1.1", - "dev": true - }, "sha.js": { "version": "2.4.11", "dev": true, @@ -39274,11 +32065,13 @@ }, "simple-concat": { "version": "1.0.1", - "dev": true + "dev": true, + "peer": true }, "simple-get": { "version": "2.8.1", "dev": true, + "peer": true, "requires": { "decompress-response": "^3.3.0", "once": "^1.3.1", @@ -39337,35 +32130,82 @@ "dev": true }, "solidity-coverage": { - "version": "0.7.17", + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.8.2.tgz", + "integrity": "sha512-cv2bWb7lOXPE9/SSleDO6czkFiMHgP4NXPj+iW9W7iEKLBk7Cj0AGBiNmGX3V1totl9wjPrT0gHmABZKZt65rQ==", "dev": true, "requires": { - "@solidity-parser/parser": "^0.13.2", - "@truffle/provider": "^0.2.24", + "@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", - "ganache-cli": "^6.12.2", "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.0" + "web3-utils": "^1.3.6" }, "dependencies": { - "@solidity-parser/parser": { - "version": "0.13.2", + "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 + }, + "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": { - "antlr4ts": "^0.5.0-alpha.4" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "chokidar": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz", + "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==", + "dev": 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" + } + }, + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "requires": { + "ms": "^2.1.1" + } + }, + "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, + "requires": { + "locate-path": "^3.0.0" } }, "fs-extra": { @@ -39377,6 +32217,27 @@ "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 + }, + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "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" + } + }, "globby": { "version": "10.0.2", "dev": true, @@ -39391,9 +32252,116 @@ "slash": "^3.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, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "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, + "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" + }, + "dependencies": { + "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, + "requires": { + "has-flag": "^3.0.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 + }, + "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, + "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, + "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 + }, "pify": { "version": "4.0.1", "dev": 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, + "requires": { + "picomatch": "^2.0.4" + } + }, + "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 + }, + "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" + } } } }, @@ -39481,7 +32449,8 @@ }, "strict-uri-encode": { "version": "1.1.0", - "dev": true + "dev": true, + "peer": true }, "string_decoder": { "version": "1.1.1", @@ -39559,101 +32528,19 @@ "dev": true }, "supports-color": { - "version": "5.5.0", + "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": "^3.0.0" - } - }, - "swarm-js": { - "version": "0.1.40", - "dev": true, - "requires": { - "bluebird": "^3.5.0", - "buffer": "^5.0.5", - "eth-lib": "^0.1.26", - "fs-extra": "^4.0.2", - "got": "^7.1.0", - "mime-types": "^2.1.16", - "mkdirp-promise": "^5.0.1", - "mock-fs": "^4.1.0", - "setimmediate": "^1.0.5", - "tar": "^4.0.2", - "xhr-request": "^1.0.1" + "has-flag": "^4.0.0" }, "dependencies": { - "eth-lib": { - "version": "0.1.29", - "dev": true, - "requires": { - "bn.js": "^4.11.6", - "elliptic": "^6.4.0", - "nano-json-stream-parser": "^0.1.2", - "servify": "^0.1.12", - "ws": "^3.0.0", - "xhr-request-promise": "^0.1.2" - } - }, - "fs-extra": { - "version": "4.0.3", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - } - }, - "get-stream": { - "version": "3.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 - }, - "got": { - "version": "7.1.0", - "dev": true, - "requires": { - "decompress-response": "^3.2.0", - "duplexer3": "^0.1.4", - "get-stream": "^3.0.0", - "is-plain-obj": "^1.1.0", - "is-retry-allowed": "^1.0.0", - "is-stream": "^1.0.0", - "isurl": "^1.0.0-alpha5", - "lowercase-keys": "^1.0.0", - "p-cancelable": "^0.3.0", - "p-timeout": "^1.1.1", - "safe-buffer": "^5.0.1", - "timed-out": "^4.0.0", - "url-parse-lax": "^1.0.0", - "url-to-options": "^1.0.1" - } - }, - "p-cancelable": { - "version": "0.3.0", - "dev": true - }, - "prepend-http": { - "version": "1.0.4", - "dev": true - }, - "safe-buffer": { - "version": "5.1.2", - "dev": true - }, - "url-parse-lax": { - "version": "1.0.0", - "dev": true, - "requires": { - "prepend-http": "^1.0.1" - } - }, - "ws": { - "version": "3.3.3", - "dev": true, - "requires": { - "async-limiter": "~1.0.0", - "safe-buffer": "~5.1.0", - "ultron": "~1.1.0" - } } } }, @@ -39673,19 +32560,6 @@ "get-port": "^3.1.0" } }, - "tar": { - "version": "4.4.19", - "dev": true, - "requires": { - "chownr": "^1.1.4", - "fs-minipass": "^1.2.7", - "minipass": "^2.9.0", - "minizlib": "^1.3.3", - "mkdirp": "^0.5.5", - "safe-buffer": "^5.2.1", - "yallist": "^3.1.1" - } - }, "test-value": { "version": "2.1.0", "dev": true, @@ -39745,7 +32619,8 @@ }, "timed-out": { "version": "4.0.1", - "dev": true + "dev": true, + "peer": true }, "tmp": { "version": "0.0.33", @@ -39754,10 +32629,6 @@ "os-tmpdir": "~1.0.2" } }, - "to-readable-stream": { - "version": "1.0.0", - "dev": true - }, "to-regex-range": { "version": "5.0.1", "dev": true, @@ -39765,10 +32636,6 @@ "is-number": "^7.0.0" } }, - "toidentifier": { - "version": "1.0.0", - "dev": true - }, "tough-cookie": { "version": "2.5.0", "dev": true, @@ -39783,10 +32650,6 @@ } } }, - "true-case-path": { - "version": "2.2.1", - "dev": true - }, "ts-essentials": { "version": "1.0.4", "dev": true @@ -39804,6 +32667,28 @@ "prettier": "^2.1.2", "resolve": "^1.8.1", "ts-essentials": "^1.0.0" + }, + "dependencies": { + "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" + } + }, + "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" + } + } } }, "ts-node": { @@ -39854,15 +32739,20 @@ }, "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": { "version": "1.2.0", - "dev": true + "dev": true, + "peer": true }, "type-check": { "version": "0.4.0", @@ -39879,14 +32769,6 @@ "version": "0.20.2", "dev": true }, - "type-is": { - "version": "1.6.18", - "dev": true, - "requires": { - "media-typer": "0.3.0", - "mime-types": "~2.1.24" - } - }, "typechain": { "version": "6.0.5", "dev": true, @@ -39921,6 +32803,7 @@ "typedarray-to-buffer": { "version": "3.1.5", "dev": true, + "peer": true, "requires": { "is-typedarray": "^1.0.0" } @@ -39938,10 +32821,6 @@ "dev": true, "optional": true }, - "ultron": { - "version": "1.1.1", - "dev": true - }, "unbox-primitive": { "version": "1.0.1", "dev": true, @@ -39952,8 +32831,10 @@ "which-boxed-primitive": "^1.0.2" } }, - "underscore": { - "version": "1.9.1", + "undici": { + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.10.0.tgz", + "integrity": "sha512-c8HsD3IbwmjjbLvoZuRI26TZic+TSEe8FPMLLOkN1AfYRhdjnKBU6yL+IwcSCbdZiX4e5t0lfMDLDCqj4Sq70g==", "dev": true }, "unfetch": { @@ -39989,24 +32870,15 @@ } } }, - "url-parse-lax": { - "version": "3.0.0", - "dev": true, - "requires": { - "prepend-http": "^2.0.0" - } - }, "url-set-query": { "version": "1.0.0", - "dev": true - }, - "url-to-options": { - "version": "1.0.1", - "dev": true + "dev": true, + "peer": true }, "utf-8-validate": { "version": "5.0.6", "dev": true, + "peer": true, "requires": { "node-gyp-build": "^4.2.0" } @@ -40018,6 +32890,7 @@ "util": { "version": "0.12.4", "dev": true, + "peer": true, "requires": { "inherits": "^2.0.3", "is-arguments": "^1.0.4", @@ -40031,10 +32904,6 @@ "version": "1.0.2", "dev": true }, - "utils-merge": { - "version": "1.0.1", - "dev": true - }, "uuid": { "version": "3.4.0", "dev": true @@ -40051,14 +32920,6 @@ "spdx-expression-parse": "^3.0.0" } }, - "varint": { - "version": "5.0.2", - "dev": true - }, - "vary": { - "version": "1.1.2", - "dev": true - }, "verror": { "version": "1.10.0", "dev": true, @@ -40068,52 +32929,10 @@ "extsprintf": "^1.2.0" } }, - "web3": { - "version": "1.5.3", - "dev": true, - "requires": { - "web3-bzz": "1.5.3", - "web3-core": "1.5.3", - "web3-eth": "1.5.3", - "web3-eth-personal": "1.5.3", - "web3-net": "1.5.3", - "web3-shh": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-bzz": { - "version": "1.5.3", - "dev": true, - "requires": { - "@types/node": "^12.12.6", - "got": "9.6.0", - "swarm-js": "^0.1.40" - }, - "dependencies": { - "@types/node": { - "version": "12.20.27", - "dev": true - } - } - }, "web3-core": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "@types/bn.js": "^4.11.5", "@types/node": "^12.12.6", @@ -40126,11 +32945,13 @@ "dependencies": { "@types/node": { "version": "12.20.27", - "dev": true + "dev": true, + "peer": true }, "web3-utils": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -40146,6 +32967,7 @@ "web3-core-helpers": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "web3-eth-iban": "1.5.3", "web3-utils": "1.5.3" @@ -40154,6 +32976,7 @@ "web3-utils": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -40169,6 +32992,7 @@ "web3-core-method": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "@ethereumjs/common": "^2.4.0", "@ethersproject/transactions": "^5.0.0-beta.135", @@ -40181,6 +33005,7 @@ "web3-utils": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -40196,6 +33021,7 @@ "web3-core-promievent": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "eventemitter3": "4.0.4" } @@ -40203,6 +33029,7 @@ "web3-core-requestmanager": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "util": "^0.12.0", "web3-core-helpers": "1.5.3", @@ -40214,208 +33041,16 @@ "web3-core-subscriptions": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "eventemitter3": "4.0.4", "web3-core-helpers": "1.5.3" } }, - "web3-eth": { - "version": "1.5.3", - "dev": true, - "requires": { - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-eth-accounts": "1.5.3", - "web3-eth-contract": "1.5.3", - "web3-eth-ens": "1.5.3", - "web3-eth-iban": "1.5.3", - "web3-eth-personal": "1.5.3", - "web3-net": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-eth-abi": { - "version": "1.5.3", - "dev": true, - "requires": { - "@ethersproject/abi": "5.0.7", - "web3-utils": "1.5.3" - }, - "dependencies": { - "@ethersproject/abi": { - "version": "5.0.7", - "dev": true, - "requires": { - "@ethersproject/address": "^5.0.4", - "@ethersproject/bignumber": "^5.0.7", - "@ethersproject/bytes": "^5.0.4", - "@ethersproject/constants": "^5.0.4", - "@ethersproject/hash": "^5.0.4", - "@ethersproject/keccak256": "^5.0.3", - "@ethersproject/logger": "^5.0.5", - "@ethersproject/properties": "^5.0.3", - "@ethersproject/strings": "^5.0.4" - } - }, - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-eth-accounts": { - "version": "1.5.3", - "dev": true, - "requires": { - "@ethereumjs/common": "^2.3.0", - "@ethereumjs/tx": "^3.2.1", - "crypto-browserify": "3.12.0", - "eth-lib": "0.2.8", - "ethereumjs-util": "^7.0.10", - "scrypt-js": "^3.0.1", - "uuid": "3.3.2", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "@types/bn.js": { - "version": "5.1.0", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "bn.js": { - "version": "5.2.0", - "dev": true - }, - "ethereumjs-util": { - "version": "7.1.1", - "dev": true, - "requires": { - "@types/bn.js": "^5.1.0", - "bn.js": "^5.1.2", - "create-hash": "^1.1.2", - "ethereum-cryptography": "^0.1.3", - "ethjs-util": "0.1.6", - "rlp": "^2.2.4" - } - }, - "uuid": { - "version": "3.3.2", - "dev": true - }, - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - }, - "dependencies": { - "bn.js": { - "version": "4.12.0", - "dev": true - } - } - } - } - }, - "web3-eth-contract": { - "version": "1.5.3", - "dev": true, - "requires": { - "@types/bn.js": "^4.11.5", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-promievent": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-eth-ens": { - "version": "1.5.3", - "dev": true, - "requires": { - "content-hash": "^2.5.2", - "eth-ens-namehash": "2.0.8", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-promievent": "1.5.3", - "web3-eth-abi": "1.5.3", - "web3-eth-contract": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, "web3-eth-iban": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.9", "web3-utils": "1.5.3" @@ -40424,61 +33059,7 @@ "web3-utils": { "version": "1.5.3", "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-eth-personal": { - "version": "1.5.3", - "dev": true, - "requires": { - "@types/node": "^12.12.6", - "web3-core": "1.5.3", - "web3-core-helpers": "1.5.3", - "web3-core-method": "1.5.3", - "web3-net": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "@types/node": { - "version": "12.20.27", - "dev": true - }, - "web3-utils": { - "version": "1.5.3", - "dev": true, - "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", - "ethereum-bloom-filters": "^1.0.6", - "ethjs-unit": "0.1.6", - "number-to-bn": "1.7.0", - "randombytes": "^2.1.0", - "utf8": "3.0.0" - } - } - } - }, - "web3-net": { - "version": "1.5.3", - "dev": true, - "requires": { - "web3-core": "1.5.3", - "web3-core-method": "1.5.3", - "web3-utils": "1.5.3" - }, - "dependencies": { - "web3-utils": { - "version": "1.5.3", - "dev": true, + "peer": true, "requires": { "bn.js": "^4.11.9", "eth-lib": "0.2.8", @@ -40494,6 +33075,7 @@ "web3-providers-http": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "web3-core-helpers": "1.5.3", "xhr2-cookies": "1.1.0" @@ -40502,6 +33084,7 @@ "web3-providers-ipc": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "oboe": "2.1.5", "web3-core-helpers": "1.5.3" @@ -40510,39 +33093,62 @@ "web3-providers-ws": { "version": "1.5.3", "dev": true, + "peer": true, "requires": { "eventemitter3": "4.0.4", "web3-core-helpers": "1.5.3", "websocket": "^1.0.32" } }, - "web3-shh": { - "version": "1.5.3", - "dev": true, - "requires": { - "web3-core": "1.5.3", - "web3-core-method": "1.5.3", - "web3-core-subscriptions": "1.5.3", - "web3-net": "1.5.3" - } - }, "web3-utils": { - "version": "1.3.5", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.8.0.tgz", + "integrity": "sha512-7nUIl7UWpLVka2f09CMbKOSEvorvHnaugIabU4mj7zfMvm0tSByLcEu3eyV9qgS11qxxLuOkzBIwCstTflhmpQ==", "dev": true, "requires": { - "bn.js": "^4.11.9", - "eth-lib": "0.2.8", + "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", - "underscore": "1.9.1", "utf8": "3.0.0" + }, + "dependencies": { + "@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": "*" + } + }, + "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 + }, + "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, + "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" + } + } } }, "websocket": { "version": "1.0.34", "dev": true, + "peer": true, "requires": { "bufferutil": "^4.0.1", "debug": "^2.2.0", @@ -40555,13 +33161,15 @@ "debug": { "version": "2.6.9", "dev": true, + "peer": true, "requires": { "ms": "2.0.0" } }, "ms": { "version": "2.0.0", - "dev": true + "dev": true, + "peer": true } } }, @@ -40590,6 +33198,7 @@ "which-typed-array": { "version": "1.1.7", "dev": true, + "peer": true, "requires": { "available-typed-arrays": "^1.0.5", "call-bind": "^1.0.2", @@ -40602,6 +33211,7 @@ "es-abstract": { "version": "1.18.6", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.2", "es-to-primitive": "^1.2.1", @@ -40625,11 +33235,13 @@ }, "is-callable": { "version": "1.2.4", - "dev": true + "dev": true, + "peer": true }, "is-regex": { "version": "1.1.4", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.2", "has-tostringtag": "^1.0.0" @@ -40638,17 +33250,20 @@ "is-string": { "version": "1.0.7", "dev": true, + "peer": true, "requires": { "has-tostringtag": "^1.0.0" } }, "object-inspect": { "version": "1.11.0", - "dev": true + "dev": true, + "peer": true }, "object.assign": { "version": "4.1.2", "dev": true, + "peer": true, "requires": { "call-bind": "^1.0.0", "define-properties": "^1.1.3", @@ -40677,6 +33292,12 @@ "version": "1.0.0", "dev": 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": "5.1.0", "dev": true, @@ -40720,6 +33341,7 @@ "xhr": { "version": "2.6.0", "dev": true, + "peer": true, "requires": { "global": "~4.4.0", "is-function": "^1.0.1", @@ -40730,6 +33352,7 @@ "xhr-request": { "version": "1.1.0", "dev": true, + "peer": true, "requires": { "buffer-to-arraybuffer": "^0.0.5", "object-assign": "^4.1.1", @@ -40743,6 +33366,7 @@ "xhr-request-promise": { "version": "0.1.3", "dev": true, + "peer": true, "requires": { "xhr-request": "^1.1.0" } @@ -40750,6 +33374,7 @@ "xhr2-cookies": { "version": "1.1.0", "dev": true, + "peer": true, "requires": { "cookiejar": "^2.1.1" } @@ -40760,7 +33385,8 @@ }, "xtend": { "version": "4.0.2", - "dev": true + "dev": true, + "peer": true }, "y18n": { "version": "4.0.3", @@ -40768,7 +33394,8 @@ }, "yaeti": { "version": "0.0.6", - "dev": true + "dev": true, + "peer": true }, "yallist": { "version": "3.1.1", @@ -40865,6 +33492,12 @@ "yn": { "version": "3.1.1", "dev": 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/package.json b/package.json index 9c39f5e..77b922f 100644 --- a/package.json +++ b/package.json @@ -5,12 +5,15 @@ "main": "index.js", "scripts": { "test": "npm run compile && TRACK_GAS=true hardhat test", - "quick-test": "hardhat test", + "qt": "hardhat test", "spdx": "hardhat prepend-spdx-license", - "size": "npm run compile && hardhat size-contracts", + "size": "npm run compile && SKIP_LOAD=true hardhat size-contracts", "full-deploy-local": "hardhat full-deploy --network localhost", "full-deploy-mumbai": "hardhat full-deploy --network mumbai", - "coverage": "npm run compile && hardhat coverage --temp temp-artifacts --testfiles test/emptyrun.coverage.ts && hardhat coverage --temp temp-artifacts --testfiles '!test/emptyrun.coverage.ts'", + "hardhat:coverage": "npm run compile && hardhat coverage --temp temp-artifacts --testfiles test/emptyrun.coverage.ts && hardhat coverage --temp temp-artifacts --testfiles '!test/emptyrun.coverage.ts'", + "foundry:coverage": "forge coverage --report lcov", + "merge:coverage": "bash scripts/mergeCoverage.sh", + "coverage": "npm run hardhat:coverage && npm run foundry:coverage && npm run merge:coverage", "run-env": "npm i && tail -f /dev/null", "hardhat": "hardhat", "hardhat:kovan": "hardhat --network kovan", @@ -50,16 +53,17 @@ "eslint-config-prettier": "8.3.0", "eslint-plugin-prettier": "4.0.0", "ethereum-waffle": "3.4.0", - "ethers": "5.5.1", - "hardhat": "2.7.0", + "ethers": "^5.7.1", + "hardhat": "^2.12.0", "hardhat-contract-sizer": "2.1.1", "hardhat-gas-reporter": "1.0.6", "hardhat-log-remover": "2.0.2", "hardhat-spdx-license-identifier": "2.0.3", + "hardhat-tracer": "^1.1.0-rc.6", "husky": "7.0.4", "prettier": "2.5.0", "prettier-plugin-solidity": "1.0.0-beta.19", - "solidity-coverage": "0.7.17", + "solidity-coverage": "^0.8.2", "ts-generator": "0.1.1", "ts-node": "10.4.0", "typechain": "6.0.5", diff --git a/remappings.txt b/remappings.txt new file mode 100644 index 0000000..1076a42 --- /dev/null +++ b/remappings.txt @@ -0,0 +1,2 @@ +ds-test/=lib/forge-std/lib/ds-test/src/ +forge-std/=lib/forge-std/src/ \ No newline at end of file diff --git a/scripts/getProxyAdmin.sh b/scripts/getProxyAdmin.sh new file mode 100644 index 0000000..c20ba89 --- /dev/null +++ b/scripts/getProxyAdmin.sh @@ -0,0 +1,17 @@ +source .env + +if [[ $1 == "" ]] + then + echo "Usage:" + echo " bash getProxyAdmin.sh [address]" + echo " Where [address] is the TransparentUpgradeableProxy address" + exit 1 +fi + +# TransparentUpgradeableProxy implementation slot +adminSlot="0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103" + +rawOldImplAddress=$(cast storage $1 $adminSlot --rpc-url $POLYGON_RPC_URL) + +echo "Admin of $1 TransparentUpgradeableProxy is:" +echo "0x${rawOldImplAddress:26}" diff --git a/scripts/mergeCoverage.sh b/scripts/mergeCoverage.sh new file mode 100644 index 0000000..a6943b8 --- /dev/null +++ b/scripts/mergeCoverage.sh @@ -0,0 +1,3 @@ +lcov -a lcov.info -a coverage/lcov.info -o lcov_merged.info +lcov -r lcov_merged.info 'test/*' '*contracts/core/modules/collect/*' '*contracts/core/modules/deprecated/*' '*contracts/core/modules/follow/*' '*contracts/core/modules/reference/*' '*contracts/core/modules/*Base.sol' '*contracts/mocks/*' -o lcov_merged_clean.info +genhtml lcov_merged_clean.info --rc lcov_branch_coverage=1 -o coverage_merged -s diff --git a/tasks/full-deploy-verify.ts b/tasks/full-deploy-verify.ts index 43bd907..316a2b7 100644 --- a/tasks/full-deploy-verify.ts +++ b/tasks/full-deploy-verify.ts @@ -12,11 +12,10 @@ import { FeeFollowModule__factory, FollowerOnlyReferenceModule__factory, FollowNFT__factory, - InteractionLogic__factory, LimitedFeeCollectModule__factory, LimitedTimedFeeCollectModule__factory, ModuleGlobals__factory, - PublishingLogic__factory, + GeneralLib__factory, RevertCollectModule__factory, TimedFeeCollectModule__factory, TransparentUpgradeableProxy__factory, @@ -77,15 +76,10 @@ task('full-deploy-verify', 'deploys the entire Lens Protocol with explorer verif console.log('\n\t-- Deploying Logic Libs --'); - const publishingLogic = await deployWithVerify( - new PublishingLogic__factory(deployer).deploy({ nonce: deployerNonce++ }), + const generalLib = await deployWithVerify( + new GeneralLib__factory(deployer).deploy({ nonce: deployerNonce++ }), [], - 'contracts/libraries/PublishingLogic.sol:PublishingLogic' - ); - const interactionLogic = await deployWithVerify( - new InteractionLogic__factory(deployer).deploy({ nonce: deployerNonce++ }), - [], - 'contracts/libraries/InteractionLogic.sol:InteractionLogic' + 'contracts/libraries/GeneralLib.sol:GeneralLib' ); const profileTokenURILogic = await deployWithVerify( new ProfileTokenURILogic__factory(deployer).deploy({ nonce: deployerNonce++ }), @@ -93,8 +87,7 @@ task('full-deploy-verify', 'deploys the entire Lens Protocol with explorer verif 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic' ); const hubLibs = { - 'contracts/libraries/PublishingLogic.sol:PublishingLogic': publishingLogic.address, - 'contracts/libraries/InteractionLogic.sol:InteractionLogic': interactionLogic.address, + 'contracts/libraries/GeneralLib.sol:GeneralLib': generalLib.address, 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic': profileTokenURILogic.address, }; @@ -351,8 +344,7 @@ task('full-deploy-verify', 'deploys the entire Lens Protocol with explorer verif const addrs = { 'lensHub proxy': lensHub.address, 'lensHub impl:': lensHubImpl.address, - 'publishing logic lib': publishingLogic.address, - 'interaction logic lib': interactionLogic.address, + 'publishing logic lib': generalLib.address, 'profile token URI logic lib': profileTokenURILogic.address, 'follow NFT impl': followNFTImplAddress, 'collect NFT impl': collectNFTImplAddress, diff --git a/tasks/full-deploy.ts b/tasks/full-deploy.ts index 522d59a..c832aef 100644 --- a/tasks/full-deploy.ts +++ b/tasks/full-deploy.ts @@ -12,11 +12,10 @@ import { FeeFollowModule__factory, FollowerOnlyReferenceModule__factory, FollowNFT__factory, - InteractionLogic__factory, LimitedFeeCollectModule__factory, LimitedTimedFeeCollectModule__factory, ModuleGlobals__factory, - PublishingLogic__factory, + GeneralLib__factory, RevertCollectModule__factory, TimedFeeCollectModule__factory, TransparentUpgradeableProxy__factory, @@ -59,18 +58,14 @@ task('full-deploy', 'deploys the entire Lens Protocol').setAction(async ({}, hre console.log('\n\t-- Deploying Logic Libs --'); - const publishingLogic = await deployContract( - new PublishingLogic__factory(deployer).deploy({ nonce: deployerNonce++ }) - ); - const interactionLogic = await deployContract( - new InteractionLogic__factory(deployer).deploy({ nonce: deployerNonce++ }) + const generalLib = await deployContract( + new GeneralLib__factory(deployer).deploy({ nonce: deployerNonce++ }) ); const profileTokenURILogic = await deployContract( new ProfileTokenURILogic__factory(deployer).deploy({ nonce: deployerNonce++ }) ); const hubLibs = { - 'contracts/libraries/PublishingLogic.sol:PublishingLogic': publishingLogic.address, - 'contracts/libraries/InteractionLogic.sol:InteractionLogic': interactionLogic.address, + 'contracts/libraries/GeneralLib.sol:GeneralLib': generalLib.address, 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic': profileTokenURILogic.address, }; @@ -293,8 +288,7 @@ task('full-deploy', 'deploys the entire Lens Protocol').setAction(async ({}, hre const addrs = { 'lensHub proxy': lensHub.address, 'lensHub impl:': lensHubImpl.address, - 'publishing logic lib': publishingLogic.address, - 'interaction logic lib': interactionLogic.address, + 'publishing logic lib': generalLib.address, 'follow NFT impl': followNFTImplAddress, 'collect NFT impl': collectNFTImplAddress, currency: currency.address, diff --git a/tasks/list-storage.ts b/tasks/list-storage.ts new file mode 100644 index 0000000..5010603 --- /dev/null +++ b/tasks/list-storage.ts @@ -0,0 +1,11 @@ +import '@nomiclabs/hardhat-ethers'; +import { task } from 'hardhat/config'; + +task('list-storage', '').setAction(async ({}, hre) => { + const ethers = hre.ethers; + const addr = '0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d'; + for (let i = 0; i < 100; ++i) { + const storageSlot = await ethers.provider.getStorageAt(addr, i); + console.log(`Hub proxy storage at slot ${i}: ${storageSlot}`); + } +}); diff --git a/tasks/testnet-full-deploy-verify.ts b/tasks/testnet-full-deploy-verify.ts index 32f66af..8df86b7 100644 --- a/tasks/testnet-full-deploy-verify.ts +++ b/tasks/testnet-full-deploy-verify.ts @@ -12,11 +12,10 @@ import { FeeFollowModule__factory, FollowerOnlyReferenceModule__factory, FollowNFT__factory, - InteractionLogic__factory, LimitedFeeCollectModule__factory, LimitedTimedFeeCollectModule__factory, ModuleGlobals__factory, - PublishingLogic__factory, + GeneralLib__factory, RevertCollectModule__factory, TimedFeeCollectModule__factory, TransparentUpgradeableProxy__factory, @@ -76,15 +75,10 @@ task( console.log('\n\t-- Deploying Logic Libs --'); - const publishingLogic = await deployWithVerify( - new PublishingLogic__factory(deployer).deploy({ nonce: deployerNonce++ }), + const generalLib = await deployWithVerify( + new GeneralLib__factory(deployer).deploy({ nonce: deployerNonce++ }), [], - 'contracts/libraries/PublishingLogic.sol:PublishingLogic' - ); - const interactionLogic = await deployWithVerify( - new InteractionLogic__factory(deployer).deploy({ nonce: deployerNonce++ }), - [], - 'contracts/libraries/InteractionLogic.sol:InteractionLogic' + 'contracts/libraries/GeneralLib.sol:GeneralLib' ); const profileTokenURILogic = await deployWithVerify( new ProfileTokenURILogic__factory(deployer).deploy({ nonce: deployerNonce++ }), @@ -92,8 +86,7 @@ task( 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic' ); const hubLibs = { - 'contracts/libraries/PublishingLogic.sol:PublishingLogic': publishingLogic.address, - 'contracts/libraries/InteractionLogic.sol:InteractionLogic': interactionLogic.address, + 'contracts/libraries/GeneralLib.sol:GeneralLib': generalLib.address, 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic': profileTokenURILogic.address, }; @@ -339,8 +332,7 @@ task( const addrs = { 'lensHub proxy': lensHub.address, 'lensHub impl:': lensHubImpl.address, - 'publishing logic lib': publishingLogic.address, - 'interaction logic lib': interactionLogic.address, + 'publishing logic lib': generalLib.address, 'profile token URI logic lib': profileTokenURILogic.address, 'follow NFT impl': followNFTImplAddress, 'collect NFT impl': collectNFTImplAddress, diff --git a/test/__setup.spec.ts b/test/__setup.spec.ts index 31e6019..85fb27a 100644 --- a/test/__setup.spec.ts +++ b/test/__setup.spec.ts @@ -1,4 +1,4 @@ -import { AbiCoder } from '@ethersproject/contracts/node_modules/@ethersproject/abi'; +import { AbiCoder } from 'ethers/lib/utils'; import { parseEther } from '@ethersproject/units'; import '@nomiclabs/hardhat-ethers'; import { expect, use } from 'chai'; @@ -24,7 +24,6 @@ import { FollowNFT__factory, Helper, Helper__factory, - InteractionLogic__factory, LensHub, LensHub__factory, LimitedFeeCollectModule, @@ -38,7 +37,7 @@ import { ModuleGlobals, ModuleGlobals__factory, ProfileTokenURILogic__factory, - PublishingLogic__factory, + GeneralLib__factory, RevertCollectModule, RevertCollectModule__factory, TimedFeeCollectModule, @@ -52,6 +51,8 @@ import { CollectNFT, RevertFollowModule, RevertFollowModule__factory, + PublishingLib__factory, + ProfileLib__factory, } from '../typechain-types'; import { LensHubLibraryAddresses } from '../typechain-types/factories/LensHub__factory'; import { FAKE_PRIVATEKEY, ZERO_ADDRESS } from './helpers/constants'; @@ -164,12 +165,14 @@ before(async function () { treasuryAddress, TREASURY_FEE_BPS ); - const publishingLogic = await new PublishingLogic__factory(deployer).deploy(); - const interactionLogic = await new InteractionLogic__factory(deployer).deploy(); + const generalLib = await new GeneralLib__factory(deployer).deploy(); + const profileLib = await new ProfileLib__factory(deployer).deploy(); + const publishingLib = await new PublishingLib__factory(deployer).deploy(); const profileTokenURILogic = await new ProfileTokenURILogic__factory(deployer).deploy(); hubLibs = { - 'contracts/libraries/PublishingLogic.sol:PublishingLogic': publishingLogic.address, - 'contracts/libraries/InteractionLogic.sol:InteractionLogic': interactionLogic.address, + 'contracts/libraries/PublishingLib.sol:PublishingLib': publishingLib.address, + 'contracts/libraries/ProfileLib.sol:ProfileLib': profileLib.address, + 'contracts/libraries/GeneralLib.sol:GeneralLib': generalLib.address, 'contracts/libraries/ProfileTokenURILogic.sol:ProfileTokenURILogic': profileTokenURILogic.address, }; diff --git a/test/foundry/CollectingTest.t.sol b/test/foundry/CollectingTest.t.sol new file mode 100644 index 0000000..46cf0b3 --- /dev/null +++ b/test/foundry/CollectingTest.t.sol @@ -0,0 +1,347 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './helpers/SignatureHelpers.sol'; +import './helpers/CollectingHelpers.sol'; + +// TODO add check for _initialize() called for fork tests - check name and symbol set + +contract CollectingTest_Base is BaseTest, SignatureHelpers, CollectingHelpers, SigSetup { + uint256 constant collectorProfileOwnerPk = 0xC011EEC7012; + address collectorProfileOwner; + uint256 collectorProfileId; + + uint256 constant userWithoutProfilePk = 0x105312; + address userWithoutProfile; + + function _mockCollect() internal virtual returns (uint256) { + return + _collect( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data + ); + } + + function _mockCollectWithSig(address delegatedSigner, uint256 signerPrivKey) + internal + virtual + returns (uint256) + { + bytes32 digest = _getCollectTypedDataHash( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data, + nonce, + deadline + ); + + return + _collectWithSig( + _buildCollectWithSigData( + delegatedSigner, + mockCollectData, + _getSigStruct(signerPrivKey, digest, deadline) + ) + ); + } + + function setUp() public virtual override(SigSetup, TestSetup) { + TestSetup.setUp(); + SigSetup.setUp(); + + vm.prank(profileOwner); + hub.post(mockPostData); + + collectorProfileOwner = vm.addr(collectorProfileOwnerPk); + collectorProfileId = _createProfile(collectorProfileOwner); + + userWithoutProfile = vm.addr(userWithoutProfilePk); + + mockCollectData.collectorProfileId = collectorProfileId; + } +} + +contract CollectingTest_Generic is CollectingTest_Base { + function setUp() public override { + CollectingTest_Base.setUp(); + } + + // NEGATIVES + + // Also acts like a test for cannot collect specifying another (non-owned) profile as a parameter + function testCannotCollectIfNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + vm.startPrank(otherSigner); + _mockCollect(); + } + + function testCannotCollectIfNonexistantPub() public { + mockCollectData.pubId = 2; + // Check that the publication doesn't exist. + assertEq( + _getPub(mockCollectData.publisherProfileId, mockCollectData.pubId).profileIdPointed, + 0 + ); + + vm.startPrank(collectorProfileOwner); + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _mockCollect(); + vm.stopPrank(); + } + + function testCannotCollectIfZeroPub() public { + mockCollectData.pubId = 0; + // Check that the publication doesn't exist. + assertEq( + _getPub(mockCollectData.publisherProfileId, mockCollectData.pubId).profileIdPointed, + 0 + ); + + vm.startPrank(collectorProfileOwner); + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _mockCollect(); + vm.stopPrank(); + } + + function testCannotCollect_WithoutProfile() public { + mockCollectData.collectorProfileId = _getNextProfileId(); // Non-existent profile + vm.startPrank(userWithoutProfile); + vm.expectRevert(Errors.TokenDoesNotExist.selector); + _mockCollect(); + vm.stopPrank(); + } + + function testCannotCollectIfBlocked() public { + vm.prank(profileOwner); + hub.setBlockStatus(newProfileId, _toUint256Array(collectorProfileId), _toBoolArray(true)); + vm.expectRevert(Errors.Blocked.selector); + vm.startPrank(collectorProfileOwner); + _mockCollect(); + } + + // SCENARIOS + + function testCollect() public { + uint256 startNftId = _checkCollectNFTBefore(); + + vm.startPrank(collectorProfileOwner); + uint256 nftId = _mockCollect(); + vm.stopPrank(); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testCollectMirror() public { + uint256 startNftId = _checkCollectNFTBefore(); + + vm.prank(profileOwner); + hub.mirror(mockMirrorData); + + vm.prank(collectorProfileOwner); + uint256 nftId = _mockCollect(); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testCollectMirrorOfMirrorPointsToOriginalPost() public { + uint256 startNftId = _checkCollectNFTBefore(); + uint256 startMirrorId = mockMirrorData.pubIdPointed; + + // mirror once + vm.startPrank(profileOwner); + uint256 newPubId = hub.mirror(mockMirrorData); + assertEq(newPubId, startMirrorId + 1); + + // mirror again + mockMirrorData.pubIdPointed = newPubId; + newPubId = hub.mirror(mockMirrorData); + assertEq(newPubId, startMirrorId + 2); + + // We're expecting a mirror to point at the original post ID + mockCollectData.pubId = startMirrorId; + vm.stopPrank(); + + vm.prank(collectorProfileOwner); + uint256 nftId = _mockCollect(); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testExecutorCollect() public { + uint256 startNftId = _checkCollectNFTBefore(); + + // delegate power to executor + _setDelegatedExecutorApproval(collectorProfileOwner, otherSigner, true); + + // collect from executor + vm.startPrank(otherSigner); + uint256 nftId = _mockCollect(); + vm.stopPrank(); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testExecutorCollectMirror() public { + uint256 startNftId = _checkCollectNFTBefore(); + + // mirror, then delegate power to executor + vm.prank(profileOwner); + hub.mirror(mockMirrorData); + _setDelegatedExecutorApproval(collectorProfileOwner, otherSigner, true); + + // collect from executor + vm.startPrank(otherSigner); + uint256 nftId = _mockCollect(); + vm.stopPrank(); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } +} + +contract CollectingTest_WithSig is CollectingTest_Base { + function setUp() public override { + CollectingTest_Base.setUp(); + } + + // NEGATIVES + + // Also acts like a test for cannot collect specifying another (non-owned) profile as a parameter + function testCannotCollectWithSigIfNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _mockCollectWithSig({delegatedSigner: otherSigner, signerPrivKey: otherSignerKey}); + } + + function testCannotCollectWithSigIfNonexistantPub() public { + mockCollectData.pubId = 2; + // Check that the publication doesn't exist. + assertEq( + _getPub(mockCollectData.publisherProfileId, mockCollectData.pubId).profileIdPointed, + 0 + ); + + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + function testCannotCollectWithSigIfZeroPub() public { + mockCollectData.pubId = 0; + // Check that the publication doesn't exist. + assertEq( + _getPub(mockCollectData.publisherProfileId, mockCollectData.pubId).profileIdPointed, + 0 + ); + + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + function testCannotCollectWithSig_WithoutProfile() public { + mockCollectData.collectorProfileId = _getNextProfileId(); // Non-existent profile + vm.expectRevert(Errors.TokenDoesNotExist.selector); + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: address(0), + signerPrivKey: userWithoutProfilePk + }); + } + + function testCannotCollectWithSigOnExpiredDeadline() public { + deadline = block.timestamp - 1; + vm.expectRevert(Errors.SignatureExpired.selector); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + function testCannotCollectWithSigOnInvalidNonce() public { + nonce = 5; + vm.expectRevert(Errors.SignatureInvalid.selector); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + function testCannotCollectIfNonceWasIncrementedWithAnotherAction() public { + assertEq(_getSigNonce(collectorProfileOwner), nonce, 'Wrong nonce before posting'); + + uint256 expectedCollectId = _getCollectCount(collectorProfileId, mockCollectData.pubId) + 1; + + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: address(0), + signerPrivKey: collectorProfileOwnerPk + }); + + assertEq(nftId, expectedCollectId, 'Wrong collectId'); + + assertTrue(_getSigNonce(collectorProfileOwner) != nonce, 'Wrong nonce after collecting'); + + vm.expectRevert(Errors.SignatureInvalid.selector); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + function testCannotCollectWithSigIfBlocked() public { + vm.prank(profileOwner); + hub.setBlockStatus(newProfileId, _toUint256Array(collectorProfileId), _toBoolArray(true)); + vm.expectRevert(Errors.Blocked.selector); + vm.startPrank(collectorProfileOwner); + _mockCollectWithSig({delegatedSigner: address(0), signerPrivKey: collectorProfileOwnerPk}); + } + + // SCENARIOS + + function testCollectWithSig() public { + uint256 startNftId = _checkCollectNFTBefore(); + + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: address(0), + signerPrivKey: collectorProfileOwnerPk + }); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testCollectWithSigMirror() public { + uint256 startNftId = _checkCollectNFTBefore(); + + vm.prank(profileOwner); + hub.mirror(mockMirrorData); + + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: address(0), + signerPrivKey: collectorProfileOwnerPk + }); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testExecutorCollectWithSig() public { + uint256 startNftId = _checkCollectNFTBefore(); + + // delegate power to executor + _setDelegatedExecutorApproval(collectorProfileOwner, otherSigner, true); + + // collect from executor + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: otherSigner, + signerPrivKey: otherSignerKey + }); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } + + function testExecutorCollectWithSigMirror() public { + uint256 startNftId = _checkCollectNFTBefore(); + + // mirror, then delegate power to executor + vm.prank(profileOwner); + hub.mirror(mockMirrorData); + _setDelegatedExecutorApproval(collectorProfileOwner, otherSigner, true); + + // collect from executor + uint256 nftId = _mockCollectWithSig({ + delegatedSigner: otherSigner, + signerPrivKey: otherSignerKey + }); + + _checkCollectNFTAfter(nftId, startNftId + 1); + } +} diff --git a/test/foundry/Constants.sol b/test/foundry/Constants.sol new file mode 100644 index 0000000..21762da --- /dev/null +++ b/test/foundry/Constants.sol @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +uint256 constant FIRST_PROFILE_ID = 1; +uint256 constant FIRST_PUB_ID = 1; +uint256 constant ISSECP256K1_CURVE_ORDER = 115792089237316195423570985008687907852837564279074904382605163141518161494337; diff --git a/test/foundry/DefaultProfileFunctionality.t.sol b/test/foundry/DefaultProfileFunctionality.t.sol new file mode 100644 index 0000000..b75facf --- /dev/null +++ b/test/foundry/DefaultProfileFunctionality.t.sol @@ -0,0 +1,174 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './helpers/SignatureHelpers.sol'; + +contract DefaultProfileFunctionalityTest_Generic is BaseTest { + function setUp() public override { + TestSetup.setUp(); + } + + // NEGATIVES + + function testCannotSetProfileOwnedByAnotherAccount() public { + vm.prank(otherSigner); + vm.expectRevert(Errors.NotProfileOwner.selector); + hub.setDefaultProfile(otherSigner, FIRST_PROFILE_ID); + } + + // SCENARIOS + + function testCanSetDefaultProfile() public { + vm.prank(profileOwner); + hub.setDefaultProfile(profileOwner, FIRST_PROFILE_ID); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + } + + function testCanSetThenUnsetDefaultProfile() public { + vm.startPrank(profileOwner); + hub.setDefaultProfile(profileOwner, FIRST_PROFILE_ID); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + hub.setDefaultProfile(profileOwner, 0); + assertEq(hub.getDefaultProfile(profileOwner), 0); + + vm.stopPrank(); + } + + function testCanSetThenChangeDefaultProfile() public { + vm.prank(profileOwner); + hub.setDefaultProfile(profileOwner, FIRST_PROFILE_ID); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + + uint256 newProfileId = hub.createProfile(mockCreateProfileData); + + vm.prank(profileOwner); + hub.setDefaultProfile(profileOwner, newProfileId); + assertEq(hub.getDefaultProfile(profileOwner), newProfileId); + } + + function testTransferUnsetsDefaultProfile() public { + vm.startPrank(profileOwner); + hub.setDefaultProfile(profileOwner, FIRST_PROFILE_ID); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + + hub.transferFrom(profileOwner, otherSigner, FIRST_PROFILE_ID); + + assertEq(hub.getDefaultProfile(profileOwner), 0); + } +} + +contract DefaultProfileFunctionalityTest_WithSig is BaseTest, SigSetup, SignatureHelpers { + function _setDefaultProfileWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 possiblyBadDeadline + ) public { + bytes32 digest = _getSetDefaulProfileTypedDataHash( + mockSetDefaultProfileData.wallet, + mockSetDefaultProfileData.profileId, + nonce, + deadline + ); + + vm.prank(delegatedSigner); + hub.setDefaultProfileWithSig( + _buildSetDefaultProfileWithSigData( + delegatedSigner, + mockSetDefaultProfileData.wallet, + mockSetDefaultProfileData.profileId, + _getSigStruct(signerPrivKey, digest, possiblyBadDeadline) + ) + ); + } + + function setUp() public override(SigSetup, TestSetup) { + TestSetup.setUp(); + SigSetup.setUp(); + } + + // NEGATIVES + + function testCannotSetDefaultProfileWithSigIfDeadlineMismatch() public { + vm.expectRevert(Errors.SignatureInvalid.selector); + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: block.timestamp + 1 + }); + } + + function testCannotSetDefaultProfileWithSigIfInvalidDeadline() public { + vm.expectRevert(Errors.SignatureExpired.selector); + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: 0 + }); + } + + function testCannotSetDefaultProfileWithSigIfInvalidNonce() public { + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + vm.expectRevert(Errors.SignatureInvalid.selector); + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + } + + // SCENARIOS + + function testCanSetDefaultProfileWithSig() public { + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + } + + function testCanSetDefaultProfileWithSigThenUnset() public { + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + + mockSetDefaultProfileData.profileId = 0; + nonce++; + + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + assertEq(hub.getDefaultProfile(profileOwner), 0); + } + + function testCanSetDefaultProfileWithSigThenChange() public { + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + assertEq(hub.getDefaultProfile(profileOwner), FIRST_PROFILE_ID); + + uint256 anotherProfileId = hub.createProfile(mockCreateProfileData); + mockSetDefaultProfileData.profileId = anotherProfileId; + nonce++; + + _setDefaultProfileWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + possiblyBadDeadline: deadline + }); + assertEq(hub.getDefaultProfile(profileOwner), mockSetDefaultProfileData.profileId); + assertFalse(mockSetDefaultProfileData.profileId == FIRST_PROFILE_ID); + } +} diff --git a/test/foundry/DelegatedExecutorTest.t.sol b/test/foundry/DelegatedExecutorTest.t.sol new file mode 100644 index 0000000..3e469ac --- /dev/null +++ b/test/foundry/DelegatedExecutorTest.t.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; + +contract DelegatedExecutorTest is BaseTest { + // Negatives + + // Positives + function testSetDelegatedExecutor() public { + hub.setDelegatedExecutorApproval(otherSigner, true); + assertEq(hub.isDelegatedExecutorApproved(me, otherSigner), true); + } + + // Meta-tx + // Negatives + + // Positives + function testSetDelegatedExecutorWithSig() public { + address onBehalfOf = profileOwner; + address executor = otherSigner; + bool approved = true; + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + + bytes32 digest = _getSetDelegatedExecutorApprovalTypedDataHash( + onBehalfOf, + executor, + approved, + nonce, + deadline + ); + hub.setDelegatedExecutorApprovalWithSig( + _buildSetDelegatedExecutorApprovalWithSigData( + onBehalfOf, + executor, + approved, + _getSigStruct(profileOwnerKey, digest, deadline) + ) + ); + + assertEq(hub.isDelegatedExecutorApproved(profileOwner, executor), true); + } +} diff --git a/test/foundry/ERC721Test.t.sol b/test/foundry/ERC721Test.t.sol new file mode 100644 index 0000000..d89ab94 --- /dev/null +++ b/test/foundry/ERC721Test.t.sol @@ -0,0 +1,322 @@ +// SPDX-License-Identifier: AGPL-3.0-only +// File modified from https://github.com/transmissions11/solmate/blob/main/src/test/ERC721.t.sol +pragma solidity 0.8.15; + +import 'forge-std/Test.sol'; + +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; +import {IERC721Receiver} from '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol'; + +contract ERC721Recipient is IERC721Receiver { + address public operator; + address public from; + uint256 public id; + bytes public data; + + function onERC721Received( + address _operator, + address _from, + uint256 _id, + bytes calldata _data + ) public virtual override returns (bytes4) { + operator = _operator; + from = _from; + id = _id; + data = _data; + + return IERC721Receiver.onERC721Received.selector; + } +} + +contract RevertingERC721Recipient is IERC721Receiver { + function onERC721Received( + address, + address, + uint256, + bytes calldata + ) public virtual override returns (bytes4) { + revert(string(abi.encodePacked(IERC721Receiver.onERC721Received.selector))); + } +} + +contract WrongReturnDataERC721Recipient is IERC721Receiver { + function onERC721Received( + address, + address, + uint256, + bytes calldata + ) public virtual override returns (bytes4) { + return 0xCAFEBEEF; + } +} + +contract NonERC721Recipient {} + +abstract contract ERC721Test is Test { + function _getERC721TokenAddress() internal view virtual returns (address); + + function _mintERC721(address to) internal virtual returns (uint256); + + function _burnERC721(uint256 tokenId) internal virtual; + + // function _getExpectedName() internal virtual returns (string memory); + + // function _getExpectedSymbol() internal virtual returns (string memory); + + function _getUnexistentTokenId() internal view virtual returns (uint256) { + return type(uint256).max; + } + + function _token() internal view virtual returns (IERC721) { + return IERC721(_getERC721TokenAddress()); + } + + // function invariantMetadata() public { + // assertEq(_token().name(), _getExpectedName('')); + // assertEq(_token().symbol(), _getExpectedSymbol('')); + // } + + function testMint() public { + uint256 tokenId = _mintERC721(address(0xBEEF)); + + assertEq(_token().balanceOf(address(0xBEEF)), 1); + assertEq(_token().ownerOf(tokenId), address(0xBEEF)); + } + + function testBurn() public { + uint256 tokenId = _mintERC721(address(this)); + assertEq(_token().balanceOf(address(this)), 1); + _burnERC721(tokenId); + assertEq(_token().balanceOf(address(this)), 0); + + vm.expectRevert(); + _token().ownerOf(tokenId); + } + + function testApprove() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().approve(address(0xBEEF), tokenId); + + assertEq(_token().getApproved(tokenId), address(0xBEEF)); + } + + function testApproveAll() public { + _token().setApprovalForAll(address(0xBEEF), true); + + assertTrue(_token().isApprovedForAll(address(this), address(0xBEEF))); + } + + function testTransferFrom() public { + address from = address(0xABCD); + + uint256 tokenId = _mintERC721(from); + + vm.prank(from); + _token().approve(address(this), tokenId); + + _token().transferFrom(from, address(0xBEEF), tokenId); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(0xBEEF)); + assertEq(_token().balanceOf(address(0xBEEF)), 1); + assertEq(_token().balanceOf(from), 0); + } + + function testTransferFromSelf() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().transferFrom(address(this), address(0xBEEF), tokenId); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(0xBEEF)); + assertEq(_token().balanceOf(address(0xBEEF)), 1); + assertEq(_token().balanceOf(address(this)), 0); + } + + function testTransferFromApproveAll() public { + address from = address(0xABCD); + + uint256 tokenId = _mintERC721(from); + + vm.prank(from); + _token().setApprovalForAll(address(this), true); + + _token().transferFrom(from, address(0xBEEF), tokenId); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(0xBEEF)); + assertEq(_token().balanceOf(address(0xBEEF)), 1); + assertEq(_token().balanceOf(from), 0); + } + + function testSafeTransferFromToEOA() public { + address from = address(0xABCD); + + uint256 tokenId = _mintERC721(from); + + vm.prank(from); + _token().setApprovalForAll(address(this), true); + + _token().safeTransferFrom(from, address(0xBEEF), tokenId); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(0xBEEF)); + assertEq(_token().balanceOf(address(0xBEEF)), 1); + assertEq(_token().balanceOf(from), 0); + } + + function testSafeTransferFromToERC721Recipient() public { + address from = address(0xABCD); + ERC721Recipient recipient = new ERC721Recipient(); + + uint256 tokenId = _mintERC721(from); + + vm.prank(from); + _token().setApprovalForAll(address(this), true); + + _token().safeTransferFrom(from, address(recipient), tokenId); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(recipient)); + assertEq(_token().balanceOf(address(recipient)), 1); + assertEq(_token().balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), tokenId); + assertEq(recipient.data(), ''); + } + + function testSafeTransferFromToERC721RecipientWithData() public { + address from = address(0xABCD); + ERC721Recipient recipient = new ERC721Recipient(); + + uint256 tokenId = _mintERC721(from); + + vm.prank(from); + _token().setApprovalForAll(address(this), true); + + _token().safeTransferFrom(from, address(recipient), tokenId, 'testing 123'); + + assertEq(_token().getApproved(tokenId), address(0)); + assertEq(_token().ownerOf(tokenId), address(recipient)); + assertEq(_token().balanceOf(address(recipient)), 1); + assertEq(_token().balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), tokenId); + assertEq(recipient.data(), 'testing 123'); + } + + function testFailMintToZero() public { + _mintERC721(address(0)); + } + + function testFailBurnUnMinted() public { + _burnERC721(_getUnexistentTokenId()); + } + + function testFailDoubleBurn() public { + uint256 tokenId = _mintERC721(address(0xBEEF)); + + _burnERC721(tokenId); + _burnERC721(tokenId); + } + + function testFailApproveUnMinted() public { + _token().approve(address(0xBEEF), _getUnexistentTokenId()); + } + + function testFailApproveUnAuthorized() public { + uint256 tokenId = _mintERC721(address(0xCAFE)); + + _token().approve(address(0xBEEF), tokenId); + } + + function testFailTransferFromUnOwned() public { + _token().transferFrom(address(0xFEED), address(0xBEEF), _getUnexistentTokenId()); + } + + function testFailTransferFromWrongFrom() public { + uint256 tokenId = _mintERC721(address(0xCAFE)); + + _token().transferFrom(address(0xFEED), address(0xBEEF), tokenId); + } + + function testFailTransferFromToZero() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().transferFrom(address(this), address(0), tokenId); + } + + function testFailTransferFromNotOwner() public { + uint256 tokenId = _mintERC721(address(0xFEED)); + + _token().transferFrom(address(0xFEED), address(0xBEEF), tokenId); + } + + function testFailSafeTransferFromToNonERC721Recipient() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom(address(this), address(new NonERC721Recipient()), tokenId); + } + + function testFailSafeTransferFromToNonERC721RecipientWithData() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom( + address(this), + address(new NonERC721Recipient()), + tokenId, + 'testing 123' + ); + } + + function testFailSafeTransferFromToRevertingERC721Recipient() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom(address(this), address(new RevertingERC721Recipient()), tokenId); + } + + function testFailSafeTransferFromToRevertingERC721RecipientWithData() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom( + address(this), + address(new RevertingERC721Recipient()), + tokenId, + 'testing 123' + ); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnData() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom( + address(this), + address(new WrongReturnDataERC721Recipient()), + tokenId + ); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnDataWithData() public { + uint256 tokenId = _mintERC721(address(this)); + + _token().safeTransferFrom( + address(this), + address(new WrongReturnDataERC721Recipient()), + tokenId, + 'testing 123' + ); + } + + function testFailBalanceOfZeroAddress() public view { + _token().balanceOf(address(0)); + } + + function testFailOwnerOfUnminted() public view { + _token().ownerOf(_getUnexistentTokenId()); + } +} diff --git a/test/foundry/Events.t.sol b/test/foundry/Events.t.sol new file mode 100644 index 0000000..cc2e318 --- /dev/null +++ b/test/foundry/Events.t.sol @@ -0,0 +1,473 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; + +import {Events} from 'contracts/libraries/Events.sol'; +import {MockFollowModule} from 'contracts/mocks/MockFollowModule.sol'; + +contract EventTest is BaseTest { + address profileOwnerTwo = address(0x2222); + address mockFollowModule; + + // Non-Lens Events + event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); + event Upgraded(address indexed implementation); + event AdminChanged(address previousAdmin, address newAdmin); + + function setUp() public override { + TestSetup.setUp(); + mockFollowModule = address(new MockFollowModule()); + vm.prank(governance); + hub.whitelistFollowModule(mockFollowModule, true); + } + + function predictContractAddress(address user, uint256 distanceFromCurrentNonce) + internal + returns (address) + { + return computeCreateAddress(user, vm.getNonce(user) + distanceFromCurrentNonce); + } + + // MISC + + function testProxyInitEmitsExpectedEvents() public { + string memory expectedNFTName = 'Lens Protocol Profiles'; + string memory expectedNFTSymbol = 'LPP'; + + vm.startPrank(deployer); + + address followNFTAddr = predictContractAddress(deployer, 1); + address collectNFTAddr = predictContractAddress(deployer, 2); + hubProxyAddr = predictContractAddress(deployer, 3); + + // Deploy implementation contracts. + hubImpl = new LensHub(followNFTAddr, collectNFTAddr); + followNFT = new FollowNFT(hubProxyAddr); + collectNFT = new CollectNFT(hubProxyAddr); + + // Deploy and initialize proxy. + bytes memory initData = abi.encodeCall( + hubImpl.initialize, + (expectedNFTName, expectedNFTSymbol, governance) + ); + + // Event tests + // Upgraded + vm.expectEmit(true, false, false, true, hubProxyAddr); + emit Upgraded(address(hubImpl)); + + // BaseInitialized + vm.expectEmit(false, false, false, true, hubProxyAddr); + emit Events.BaseInitialized(expectedNFTName, expectedNFTSymbol, block.timestamp); + + // StateSet + vm.expectEmit(true, true, true, true, hubProxyAddr); + emit Events.StateSet( + deployer, + DataTypes.ProtocolState.Unpaused, + DataTypes.ProtocolState.Paused, + block.timestamp + ); + + // GovernanceSet + vm.expectEmit(true, true, true, true, hubProxyAddr); + emit Events.GovernanceSet(deployer, address(0), governance, block.timestamp); + + // AdminChanged + vm.expectEmit(false, false, false, true, hubProxyAddr); + emit AdminChanged(address(0), deployer); + + hubAsProxy = new TransparentUpgradeableProxy(address(hubImpl), deployer, initData); + vm.stopPrank(); + } + + // HUB GOVERNANCE + + function testGovernanceEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.GovernanceSet(governance, governance, me, block.timestamp); + hub.setGovernance(me); + } + + function testEmergencyAdminChangeEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.EmergencyAdminSet(governance, address(0), me, block.timestamp); + hub.setEmergencyAdmin(me); + } + + function testProtocolStateChangeByGovEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.StateSet( + governance, + DataTypes.ProtocolState.Unpaused, + DataTypes.ProtocolState.Paused, + block.timestamp + ); + hub.setState(DataTypes.ProtocolState.Paused); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.StateSet( + governance, + DataTypes.ProtocolState.Paused, + DataTypes.ProtocolState.PublishingPaused, + block.timestamp + ); + hub.setState(DataTypes.ProtocolState.PublishingPaused); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.StateSet( + governance, + DataTypes.ProtocolState.PublishingPaused, + DataTypes.ProtocolState.Unpaused, + block.timestamp + ); + hub.setState(DataTypes.ProtocolState.Unpaused); + } + + function testProtocolStateChangeByEmergencyAdminEmitsExpectedEvents() public { + vm.prank(governance); + hub.setEmergencyAdmin(profileOwner); + + vm.prank(profileOwner); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.StateSet( + profileOwner, + DataTypes.ProtocolState.Unpaused, + DataTypes.ProtocolState.PublishingPaused, + block.timestamp + ); + hub.setState(DataTypes.ProtocolState.PublishingPaused); + + vm.prank(profileOwner); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.StateSet( + profileOwner, + DataTypes.ProtocolState.PublishingPaused, + DataTypes.ProtocolState.Paused, + block.timestamp + ); + hub.setState(DataTypes.ProtocolState.Paused); + } + + function testFollowModuleWhitelistEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.FollowModuleWhitelisted(me, true, block.timestamp); + hub.whitelistFollowModule(me, true); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.FollowModuleWhitelisted(me, false, block.timestamp); + hub.whitelistFollowModule(me, false); + } + + function testReferenceModuleWhitelistEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.ReferenceModuleWhitelisted(me, true, block.timestamp); + hub.whitelistReferenceModule(me, true); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.ReferenceModuleWhitelisted(me, false, block.timestamp); + hub.whitelistReferenceModule(me, false); + } + + function testCollectModuleWhitelistEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectModuleWhitelisted(me, true, block.timestamp); + hub.whitelistCollectModule(me, true); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectModuleWhitelisted(me, false, block.timestamp); + hub.whitelistCollectModule(me, false); + } + + // HUB INTERACTION + + function testProfileCreationEmitsExpectedEvents() public { + uint256 expectedTokenId = 2; + mockCreateProfileData.to = profileOwnerTwo; + vm.prank(governance); + hub.whitelistProfileCreator(profileOwnerTwo, true); + vm.prank(profileOwnerTwo); + vm.expectEmit(true, true, true, true, address(hub)); + emit Transfer(address(0), profileOwnerTwo, expectedTokenId); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.ProfileCreated( + expectedTokenId, + profileOwnerTwo, + profileOwnerTwo, + mockCreateProfileData.imageURI, + mockCreateProfileData.followModule, + '', + mockCreateProfileData.followNFTURI, + block.timestamp + ); + hub.createProfile(mockCreateProfileData); + } + + function testProfileCreationForOtherUserEmitsExpectedEvents() public { + uint256 expectedTokenId = 2; + mockCreateProfileData.to = profileOwnerTwo; + vm.expectEmit(true, true, true, true, address(hub)); + emit Transfer(address(0), profileOwnerTwo, expectedTokenId); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.ProfileCreated( + expectedTokenId, + me, + profileOwnerTwo, + mockCreateProfileData.imageURI, + mockCreateProfileData.followModule, + '', + mockCreateProfileData.followNFTURI, + block.timestamp + ); + hub.createProfile(mockCreateProfileData); + } + + function testSettingFollowModuleEmitsExpectedEvents() public { + mockCreateProfileData.to = profileOwnerTwo; + uint256 expectedProfileId = 2; + hub.createProfile(mockCreateProfileData); + vm.prank(profileOwnerTwo); + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.FollowModuleSet( + expectedProfileId, + address(mockFollowModule), + '', + block.timestamp + ); + hub.setFollowModule(expectedProfileId, address(mockFollowModule), abi.encode(1)); + } + + function testSettingDispatcherEmitsExpectedEvents() public { + mockCreateProfileData.to = profileOwnerTwo; + uint256 expectedProfileId = 2; + hub.createProfile(mockCreateProfileData); + vm.prank(profileOwnerTwo); + vm.expectEmit(true, true, false, true, address(hub)); + emit Events.DispatcherSet(expectedProfileId, me, block.timestamp); + hub.setDispatcher(expectedProfileId, me); + } + + function testPostingEmitsExpectedEvents() public { + vm.prank(profileOwner); + vm.expectEmit(true, true, false, true, address(hub)); + emit Events.PostCreated( + newProfileId, + 1, + mockPostData.contentURI, + mockPostData.collectModule, + '', + mockPostData.referenceModule, + '', + block.timestamp + ); + hub.post(mockPostData); + } + + function testCommentingEmitsExpectedEvents() public { + vm.startPrank(profileOwner); + hub.post(mockPostData); + vm.expectEmit(true, true, false, true, address(hub)); + emit Events.CommentCreated( + newProfileId, + 2, + mockCommentData.contentURI, + newProfileId, + 1, + '', + mockCommentData.collectModule, + '', + mockCommentData.referenceModule, + '', + block.timestamp + ); + hub.comment(mockCommentData); + vm.stopPrank(); + } + + function testMirroringEmitsExpectedEvents() public { + vm.startPrank(profileOwner); + hub.post(mockPostData); + vm.expectEmit(true, true, false, true, address(hub)); + emit Events.MirrorCreated( + newProfileId, + 2, + newProfileId, + 1, + '', + mockMirrorData.referenceModule, + '', + block.timestamp + ); + hub.mirror(mockMirrorData); + vm.stopPrank(); + } + + function testCollectingEmitsExpectedEvents() public { + vm.startPrank(profileOwner); + hub.post(mockPostData); + + uint256 expectedPubId = 1; + address expectedCollectNFTAddress = predictContractAddress(address(hub), 0); + string memory expectedNFTName = '1-Collect-1'; + string memory expectedNFTSymbol = '1-Cl-1'; + + // BaseInitialized + vm.expectEmit(true, true, true, true, expectedCollectNFTAddress); + emit Events.BaseInitialized(expectedNFTName, expectedNFTSymbol, block.timestamp); + + // CollectNFTInitialized + vm.expectEmit(true, true, true, true, expectedCollectNFTAddress); + emit Events.CollectNFTInitialized(newProfileId, expectedPubId, block.timestamp); + + // CollectNFTDeployed + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectNFTDeployed( + newProfileId, + expectedPubId, + expectedCollectNFTAddress, + block.timestamp + ); + + // CollectNFTTransferred + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectNFTTransferred( + newProfileId, + expectedPubId, + 1, // collect nft id + address(0), + profileOwner, + block.timestamp + ); + + // Transfer + vm.expectEmit(true, true, true, true, expectedCollectNFTAddress); + emit Transfer(address(0), profileOwner, 1); + + // Collected + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.Collected( + newProfileId, // TODO: Replace with proper ProfileID + newProfileId, + expectedPubId, + newProfileId, + expectedPubId, + '', + block.timestamp + ); + + // TODO: Replace with proper ProfileID + hub.collect(newProfileId, newProfileId, expectedPubId, ''); + vm.stopPrank(); + } + + function testCollectingFromMirrorEmitsExpectedEvents() public { + uint256[] memory followTargetIds = new uint256[](1); + followTargetIds[0] = 1; + bytes[] memory followDatas = new bytes[](1); + followDatas[0] = ''; + uint256 expectedPubId = 1; + address expectedCollectNFTAddress = predictContractAddress(address(hub), 0); + string memory expectedNFTName = '1-Collect-1'; + string memory expectedNFTSymbol = '1-Cl-1'; + + vm.startPrank(profileOwner); + hub.post(mockPostData); + hub.mirror(mockMirrorData); + + // BaseInitialized + vm.expectEmit(false, false, false, true, expectedCollectNFTAddress); + emit Events.BaseInitialized(expectedNFTName, expectedNFTSymbol, block.timestamp); + + // CollectNFTInitialized + vm.expectEmit(true, true, true, true, expectedCollectNFTAddress); + emit Events.CollectNFTInitialized(newProfileId, expectedPubId, block.timestamp); + + // CollectNFTDeployed + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectNFTDeployed( + newProfileId, + expectedPubId, + expectedCollectNFTAddress, + block.timestamp + ); + + // CollectNFTTransferred + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.CollectNFTTransferred( + newProfileId, + expectedPubId, + 1, // collect nft id + address(0), + profileOwner, + block.timestamp + ); + + // Transfer + vm.expectEmit(true, true, true, true, expectedCollectNFTAddress); + emit Transfer(address(0), profileOwner, 1); + + // Collected + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.Collected( + newProfileId, // TODO: Replace with proper ProfileID + newProfileId, + expectedPubId, + newProfileId, + expectedPubId, + '', + block.timestamp + ); + + // TODO: Replace with proper ProfileID + hub.collect(newProfileId, 1, expectedPubId, ''); + vm.stopPrank(); + } + + // MODULE GLOBALS GOVERNANCE + + function testGovernanceChangeEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(moduleGlobals)); + emit Events.ModuleGlobalsGovernanceSet(governance, me, block.timestamp); + moduleGlobals.setGovernance(me); + } + + function testTreasuryChangeEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, false, true, address(moduleGlobals)); + emit Events.ModuleGlobalsTreasurySet(treasury, me, block.timestamp); + moduleGlobals.setTreasury(me); + } + + function testTreasuryFeeChangeEmitsExpectedEvents() public { + uint16 newFee = 1; + vm.prank(governance); + vm.expectEmit(true, true, false, true, address(moduleGlobals)); + emit Events.ModuleGlobalsTreasuryFeeSet(TREASURY_FEE_BPS, newFee, block.timestamp); + moduleGlobals.setTreasuryFee(newFee); + } + + function testCurrencyWhitelistEmitsExpectedEvents() public { + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(moduleGlobals)); + emit Events.ModuleGlobalsCurrencyWhitelisted(me, false, true, block.timestamp); + moduleGlobals.whitelistCurrency(me, true); + + vm.prank(governance); + vm.expectEmit(true, true, true, true, address(moduleGlobals)); + emit Events.ModuleGlobalsCurrencyWhitelisted(me, true, false, block.timestamp); + moduleGlobals.whitelistCurrency(me, false); + } +} diff --git a/test/foundry/FollowNFTTest.t.sol b/test/foundry/FollowNFTTest.t.sol new file mode 100644 index 0000000..650b075 --- /dev/null +++ b/test/foundry/FollowNFTTest.t.sol @@ -0,0 +1,1243 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './ERC721Test.t.sol'; +import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; +import {IFollowNFT} from 'contracts/interfaces/IFollowNFT.sol'; +import {FollowNFT} from 'contracts/core/FollowNFT.sol'; + +contract FollowNFTTest is BaseTest, ERC721Test { + uint256 constant MINT_NEW_TOKEN = 0; + address targetProfileOwner; + uint256 targetProfileId; + address followerProfileOwner; + uint256 followerProfileId; + address alreadyFollowingProfileOwner; + uint256 alreadyFollowingProfileId; + address targetFollowNFT; + uint256 lastAssignedTokenId; + address followHolder; + + function setUp() public override { + super.setUp(); + + targetProfileOwner = address(0xC0FFEE); + targetProfileId = _createProfile(targetProfileOwner); + followerProfileOwner = me; + followerProfileId = _createProfile(followerProfileOwner); + + followHolder = address(0xF0110111401DE2); + + alreadyFollowingProfileOwner = address(0xF01108); + alreadyFollowingProfileId = _createProfile(alreadyFollowingProfileOwner); + lastAssignedTokenId = _follow( + alreadyFollowingProfileOwner, + alreadyFollowingProfileId, + targetProfileId, + 0, + '' + )[0]; + + targetFollowNFT = hub.getFollowNFT(targetProfileId); + followNFT = FollowNFT(targetFollowNFT); + } + + function _mintERC721(address to) internal virtual override returns (uint256) { + uint256 tokenId = _follow(to, _createProfile(to), targetProfileId, 0, '')[0]; + vm.prank(to); + followNFT.wrap(tokenId); + return tokenId; + } + + function _burnERC721(uint256 tokenId) internal virtual override { + return followNFT.burn(tokenId); + } + + function _getERC721TokenAddress() internal view virtual override returns (address) { + return targetFollowNFT; + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Follow - General - Negatives + ////////////////////////////////////////////////////////// + + function testCannotCallFollowIfNotTheHub(address sender) public { + vm.assume(sender != address(hub)); + vm.assume(sender != address(0)); + + vm.prank(sender); + + vm.expectRevert(Errors.NotHub.selector); + followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + } + + function testCannotFollowIfAlreadyFollowing() public { + vm.prank(address(hub)); + + vm.expectRevert(IFollowNFT.AlreadyFollowing.selector); + followNFT.follow({ + followerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + } + + function testCannotFollowWithTokenIfTheTokenDoesNotExist(uint256 unexistentTokenId) public { + vm.assume(unexistentTokenId != MINT_NEW_TOKEN); + vm.assume(followNFT.getFollowerProfileId(unexistentTokenId) == 0); + vm.assume(!followNFT.exists(unexistentTokenId)); + vm.assume(followNFT.getProfileIdAllowedToRecover(unexistentTokenId) == 0); + + vm.prank(address(hub)); + + vm.expectRevert(IFollowNFT.FollowTokenDoesNotExist.selector); + + followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: unexistentTokenId + }); + } + + ////////////////////////////////////////////////////////// + // Follow - Minting new token - Negatives + ////////////////////////////////////////////////////////// + + // No negatives when minting a new token, all the failing cases will occur at LensHub level. See `FollowTest.t.sol`. + + ////////////////////////////////////////////////////////// + // Follow - Minting new token - Scenarios + ////////////////////////////////////////////////////////// + + function testNewMintedTokenIdIsLastAssignedPlusOne() public { + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + assertEq(assignedTokenId, lastAssignedTokenId + 1); + } + + function testFollowingMintingNewTokenSetsFollowerStatusCorrectly() public { + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + bool isFollowing = followNFT.isFollowing(followerProfileId); + assertEq(isFollowing, true); + + uint256 followerProfileIdSet = followNFT.getFollowerProfileId(assignedTokenId); + assertEq(followerProfileIdSet, followerProfileId); + + uint256 followIdByFollower = followNFT.getFollowTokenId(followerProfileId); + assertEq(followIdByFollower, assignedTokenId); + } + + function testExpectedFollowDataAfterMintingNewToken() public { + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + IFollowNFT.FollowData memory followData = followNFT.getFollowData(assignedTokenId); + + assertEq(followData.followerProfileId, followerProfileId); + assertEq(followData.originalFollowTimestamp, block.timestamp); + assertEq(followData.followTimestamp, block.timestamp); + assertEq(followData.profileIdAllowedToRecover, 0); + } + + function testFollowTokenIsByDefaultUnwrapped() public { + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + assertTrue(followNFT.isFollowing(followerProfileId)); + + vm.expectRevert(Errors.ERC721Time_OwnerQueryForNonexistantToken.selector); + followNFT.ownerOf(assignedTokenId); + } + + ////////////////////////////////////////////////////////// + // Follow - With unwrapped token - Scenarios + ////////////////////////////////////////////////////////// + + function testFollowWithUnwrappedTokenWhenCurrentFollowerWasBurnedAndExecutorIsFollowerOwner() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + hub.burn(alreadyFollowingProfileId); + assertFalse(hub.exists(alreadyFollowingProfileId)); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + function testFollowWithUnwrappedTokenWhenCurrentFollowerWasBurnedAndExecutorIsApprovedDelegatee( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != followerProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + hub.burn(alreadyFollowingProfileId); + assertFalse(hub.exists(alreadyFollowingProfileId)); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: executorAsApprovedDelegatee, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + ////////////////////////////////////////////////////////// + // Follow - With wrapped token - Scenarios + ////////////////////////////////////////////////////////// + + function testFollowWithWrappedTokenWhenFollowerOwnerOwnsFollowTokenAndIsActingAsExecutor() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followerProfileOwner, followTokenId); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + } + + function testFollowWithWrappedTokenWhenFollowerOwnerAlsoOwnsFollowTokenAndExecutorIsApprovedDelegatee( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != followerProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followerProfileOwner, followTokenId); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: executorAsApprovedDelegatee, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + } + + function testFollowWithWrappedTokenWhenExecutorOwnsFollowTokenAndExecutorIsApprovedDelegatee( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != followerProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom( + alreadyFollowingProfileOwner, + executorAsApprovedDelegatee, + followTokenId + ); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: executorAsApprovedDelegatee, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + } + + function testFollowWithWrappedTokenWhenExecutorIsApprovedForAllAndExecutorIsFollowerOwner() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.setApprovalForAll(followerProfileOwner, true); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + } + + function testFollowWithWrappedTokenWhenExecutorIsApprovedForAllAndExecutorIsApprovedDelegatee( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != followerProfileOwner); + vm.assume(executorAsApprovedDelegatee != alreadyFollowingProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.setApprovalForAll(executorAsApprovedDelegatee, true); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: executorAsApprovedDelegatee, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + } + + function testFollowWithWrappedTokenWhenProfileIsApprovedToFollowAndExecutorIsFollowerOwner() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + function testFollowWithWrappedTokenWhenProfileIsApprovedToFollowAndExecutorIsApprovedDelegatee( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != followerProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: executorAsApprovedDelegatee, + followTokenId: followTokenId + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(followerProfileId), followTokenId); + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + ////////////////////////////////////////////////////////// + // Follow - Recovering token - Scenarios + ////////////////////////////////////////////////////////// + + function testFollowRecoveringToken() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner, + followTokenId: followTokenId + }); + + assertTrue(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(assignedTokenId, followTokenId); + assertEq(followNFT.getFollowTokenId(alreadyFollowingProfileId), followTokenId); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Unfollow - Negatives + ////////////////////////////////////////////////////////// + + function testCannotCallUnfollowIfNotTheHub(address sender) public { + vm.assume(sender != address(hub)); + vm.assume(sender != address(0)); + + vm.prank(sender); + + vm.expectRevert(Errors.NotHub.selector); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + } + + function testCannotUnfollowIfNotAlreadyFollowing() public { + assertFalse(followNFT.isFollowing(followerProfileId)); + + vm.prank(address(hub)); + + vm.expectRevert(IFollowNFT.NotFollowing.selector); + followNFT.unfollow({ + unfollowerProfileId: followerProfileId, + executor: followerProfileOwner + }); + } + + function testCannotUnfollowIfTokenIsWrappedAndUnfollowerOwnerOrExecutorDontHoldTheTokenOrApprovedForAll( + address unrelatedAddress + ) public { + vm.assume(unrelatedAddress != address(0)); + vm.assume(unrelatedAddress != alreadyFollowingProfileOwner); + vm.assume(!hub.isDelegatedExecutorApproved(alreadyFollowingProfileOwner, unrelatedAddress)); + vm.assume(!followNFT.isApprovedForAll(alreadyFollowingProfileOwner, unrelatedAddress)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, unrelatedAddress, followTokenId); + + vm.prank(address(hub)); + + vm.expectRevert(IFollowNFT.DoesNotHavePermissions.selector); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + } + + function testCannotRemoveFollowerOnWrappedIfNotHolder(address unrelatedAddress) public { + vm.assume(unrelatedAddress != address(0)); + vm.assume(unrelatedAddress != followHolder); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followHolder, followTokenId); + + vm.prank(unrelatedAddress); + + vm.expectRevert(IFollowNFT.DoesNotHavePermissions.selector); + followNFT.removeFollower({followTokenId: followTokenId}); + } + + ////////////////////////////////////////////////////////// + // Unfollow - Scenarios + ////////////////////////////////////////////////////////// + + function testUnfollowAsFollowerProfileOwnerWhenTokenIsWrapped() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + function testUnfollowAsApprovedDelegatedExecutorOfFollowerOwnerWhenTokenIsWrapped( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != alreadyFollowingProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: executorAsApprovedDelegatee + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + function testUnfollowAsFollowTokenOwnerWhenTokenIsWrapped(address followTokenOwner) public { + vm.assume(followTokenOwner != alreadyFollowingProfileOwner); + vm.assume(followTokenOwner != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followTokenOwner, followTokenId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: followTokenOwner + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + function testUnfollowAsApprovedForAllByTokenOwnerWhenTokenIsWrapped(address approvedForAll) + public + { + vm.assume(approvedForAll != alreadyFollowingProfileOwner); + vm.assume(approvedForAll != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.setApprovalForAll(approvedForAll, true); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: approvedForAll + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + function testUnfollowAsFollowerProfileOwnerWhenTokenIsUnwrapped() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + } + + function testUnfollowAsApprovedDelegatedExecutorOfFollowerOwnerWhenTokenIsUnwrapped( + address executorAsApprovedDelegatee + ) public { + vm.assume(executorAsApprovedDelegatee != alreadyFollowingProfileOwner); + vm.assume(executorAsApprovedDelegatee != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: executorAsApprovedDelegatee + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.getFollowerProfileId(alreadyFollowingProfileId), 0); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + } + + function testRemoveFollower() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followHolder, followTokenId); + + vm.prank(followHolder); + followNFT.removeFollower({followTokenId: followTokenId}); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Wrap - Negatives + ////////////////////////////////////////////////////////// + + function testCannotWrapIfAlreadyWrapped() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + + vm.expectRevert(IFollowNFT.AlreadyWrapped.selector); + followNFT.wrap(followTokenId); + } + + function testCannotWrapIfTokenDoesNotExist(uint256 unexistentTokenId) public { + vm.assume(followNFT.getFollowerProfileId(unexistentTokenId) == 0); + vm.assume(!followNFT.exists(unexistentTokenId)); + + vm.expectRevert(IFollowNFT.FollowTokenDoesNotExist.selector); + followNFT.wrap(unexistentTokenId); + } + + function testCannotWrapIfSenderIsNotFollowerOwner(address notFollowerOwner) public { + vm.assume(notFollowerOwner != alreadyFollowingProfileOwner); + vm.assume(notFollowerOwner != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(notFollowerOwner); + + vm.expectRevert(IFollowNFT.DoesNotHavePermissions.selector); + followNFT.wrap(followTokenId); + } + + function testCannotWrapRecoveringWhenTheProfileAllowedToRecoverDoesNotExistAnymore() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + hub.burn(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + vm.expectRevert(Errors.ERC721Time_OwnerQueryForNonexistantToken.selector); + followNFT.wrap(followTokenId); + } + + function testCannotWrapRecoveringWhenTheSenderDoesNotOwnTheProfileAllowedToRecover( + address unrelatedAddress + ) public { + vm.assume(unrelatedAddress != address(0)); + vm.assume(unrelatedAddress != alreadyFollowingProfileOwner); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + hub.transferFrom({ + from: alreadyFollowingProfileOwner, + to: unrelatedAddress, + tokenId: alreadyFollowingProfileId + }); + + vm.prank(alreadyFollowingProfileOwner); + vm.expectRevert(IFollowNFT.DoesNotHavePermissions.selector); + followNFT.wrap(followTokenId); + } + + ////////////////////////////////////////////////////////// + // Wrap - Scenarios + ////////////////////////////////////////////////////////// + + function testWrappedTokenOwnerIsFollowerProfileOwnerAfterUntyingAndWrapping() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + } + + function testWrappedTokenStillHeldByPreviousFollowerOwnerAfterAFollowerProfileTransfer( + address newFollowerProfileOwner + ) public { + vm.assume(newFollowerProfileOwner != followerProfileOwner); + vm.assume(newFollowerProfileOwner != address(0)); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + vm.prank(followerProfileOwner); + followNFT.wrap(assignedTokenId); + + assertEq(followNFT.ownerOf(assignedTokenId), followerProfileOwner); + + assertTrue(followNFT.isFollowing(followerProfileId)); + uint256 followerProfileIdSet = followNFT.getFollowerProfileId(assignedTokenId); + assertEq(followerProfileIdSet, followerProfileId); + + vm.prank(followerProfileOwner); + hub.transferFrom(followerProfileOwner, newFollowerProfileOwner, followerProfileId); + + assertEq(hub.ownerOf(followerProfileId), newFollowerProfileOwner); + assertEq(followNFT.ownerOf(assignedTokenId), followerProfileOwner); + + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(followerProfileIdSet, followNFT.getFollowerProfileId(assignedTokenId)); + } + + function testRecoveringTokenThroughWrappingIt() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + function testRecoveringTokenThroughWrappingItAfterProfileAllowedToRecoverWasTransferred( + address unrelatedAddress + ) public { + vm.assume(unrelatedAddress != address(0)); + vm.assume(unrelatedAddress != alreadyFollowingProfileOwner); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + hub.transferFrom({ + from: alreadyFollowingProfileOwner, + to: unrelatedAddress, + tokenId: alreadyFollowingProfileId + }); + + vm.prank(unrelatedAddress); + followNFT.wrap(followTokenId); + + assertEq(followNFT.ownerOf(followTokenId), unrelatedAddress); + assertEq(followNFT.getProfileIdAllowedToRecover(followTokenId), 0); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Unwrap - Negatives + ////////////////////////////////////////////////////////// + + function testCannotUnwrapIfTokenDoesNotHaveAFollowerSet() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + vm.expectRevert(IFollowNFT.NotFollowing.selector); + vm.prank(alreadyFollowingProfileOwner); + followNFT.unwrap(followTokenId); + } + + function testCannotUnwrapIfTokenIsAlreadyUnwrapped() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.expectRevert(Errors.ERC721Time_OperatorQueryForNonexistantToken.selector); + vm.prank(alreadyFollowingProfileOwner); + followNFT.unwrap(followTokenId); + } + + function testCannotUnwrapIfSenderIsNotTokenOwnerOrApprovedOrApprovedForAll(address sender) + public + { + // You can't approve a token that is not wrapped, so no need to check for `followNFT.getApproved(followTokenId)` + vm.assume(sender != alreadyFollowingProfileOwner); + vm.assume(sender != address(0)); + vm.assume(!followNFT.isApprovedForAll(alreadyFollowingProfileOwner, sender)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.expectRevert(Errors.NotOwnerOrApproved.selector); + vm.prank(sender); + followNFT.unwrap(followTokenId); + } + + ////////////////////////////////////////////////////////// + // Unwrap - Scenarios + ////////////////////////////////////////////////////////// + + function testTokenOwnerCanUnwrapIt() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.unwrap(followTokenId); + + assertFalse(followNFT.exists(followTokenId)); + } + + function testApprovedForAllCanUnwrapAToken(address approvedForAll) public { + vm.assume(approvedForAll != alreadyFollowingProfileOwner); + vm.assume(approvedForAll != address(0)); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.setApprovalForAll(approvedForAll, true); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(approvedForAll); + followNFT.unwrap(followTokenId); + + assertFalse(followNFT.exists(followTokenId)); + } + + function testApprovedForATokenCanUnwrapIt(address approved) public { + vm.assume(approved != alreadyFollowingProfileOwner); + vm.assume(approved != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approve(approved, followTokenId); + + vm.prank(approved); + followNFT.unwrap(followTokenId); + + assertFalse(followNFT.exists(followTokenId)); + } + + function testUnwrappedTokenStillTiedToFollowerProfileAfterAFollowerProfileTransfer( + address newFollowerProfileOwner + ) public { + vm.assume(newFollowerProfileOwner != followerProfileOwner); + vm.assume(newFollowerProfileOwner != address(0)); + + vm.prank(address(hub)); + + uint256 assignedTokenId = followNFT.follow({ + followerProfileId: followerProfileId, + executor: followerProfileOwner, + followTokenId: MINT_NEW_TOKEN + }); + + assertTrue(followNFT.isFollowing(followerProfileId)); + uint256 followerProfileIdSet = followNFT.getFollowerProfileId(assignedTokenId); + assertEq(followerProfileIdSet, followerProfileId); + + vm.prank(followerProfileOwner); + hub.transferFrom(followerProfileOwner, newFollowerProfileOwner, followerProfileId); + + assertEq(hub.ownerOf(followerProfileId), newFollowerProfileOwner); + + assertTrue(followNFT.isFollowing(followerProfileId)); + assertEq(followerProfileIdSet, followNFT.getFollowerProfileId(assignedTokenId)); + + vm.prank(newFollowerProfileOwner); + followNFT.wrap(assignedTokenId); + assertEq(followNFT.ownerOf(assignedTokenId), newFollowerProfileOwner); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Block - Negatives + ////////////////////////////////////////////////////////// + + function testCannotCallBlockIfNotTheHub(address sender) public { + vm.assume(sender != address(hub)); + vm.assume(sender != address(0)); + + vm.prank(sender); + + vm.expectRevert(Errors.NotHub.selector); + followNFT.processBlock(followerProfileId); + } + + ////////////////////////////////////////////////////////// + // Block - Scenarios + ////////////////////////////////////////////////////////// + + function testCanBlockSomeoneAlreadyBlocked() public { + vm.prank(address(hub)); + followNFT.processBlock(followerProfileId); + + vm.prank(address(hub)); + followNFT.processBlock(followerProfileId); + } + + function testBlockingFollowerThatWasFollowingWithWrappedTokenMakesHimUnfollowButKeepsTheWrappedToken() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + assertTrue(followNFT.isFollowing(alreadyFollowingProfileId)); + + vm.prank(address(hub)); + followNFT.processBlock(alreadyFollowingProfileId); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + } + + function testBlockingFollowerThatWasFollowingWithUnwrappedFirstWrapsTokenAndThenMakesHimUnfollowKeepingItWrapped() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + assertFalse(followNFT.exists(followTokenId)); + assertTrue(followNFT.isFollowing(alreadyFollowingProfileId)); + + vm.prank(address(hub)); + followNFT.processBlock(alreadyFollowingProfileId); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + } + + function testBlockingProfileThatWasNotFollowingButItsOwnerHoldsWrappedFollowTokenDoesNotChangeAnything() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(address(hub)); + followNFT.unfollow({ + unfollowerProfileId: alreadyFollowingProfileId, + executor: alreadyFollowingProfileOwner + }); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + + vm.prank(address(hub)); + followNFT.processBlock(alreadyFollowingProfileId); + + assertFalse(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.ownerOf(followTokenId), alreadyFollowingProfileOwner); + } + + function testBlockingProfileThatWasNotFollowingButItsOwnerHoldsWrappedFollowTokenWithFollowerDoesNotChangeAnything() + public + { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followerProfileOwner, followTokenId); + + assertTrue(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.ownerOf(followTokenId), followerProfileOwner); + + vm.prank(address(hub)); + followNFT.processBlock(followerProfileId); + + assertTrue(followNFT.isFollowing(alreadyFollowingProfileId)); + assertEq(followNFT.ownerOf(followTokenId), followerProfileOwner); + } + + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + ////////////////////////////////////////////////////////// + // Approve follow - Negatives + ////////////////////////////////////////////////////////// + + function testCannotApproveFollowForUnexistentProfile(uint256 unexistentProfileId) public { + vm.assume(!hub.exists(unexistentProfileId)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(unexistentProfileId, followTokenId); + } + + function testCannotApproveFollowForUnexistentFollowToken(uint256 unexistentFollowTokenId) + public + { + vm.assume(!followNFT.exists(unexistentFollowTokenId)); + vm.assume(followNFT.getFollowerProfileId(unexistentFollowTokenId) == 0); + + vm.expectRevert(IFollowNFT.OnlyWrappedFollowTokens.selector); + followNFT.approveFollow(followerProfileId, unexistentFollowTokenId); + } + + function testCannotApproveFollowForWrappedTokenIfCallerIsNotItsOwnerOrApprovedForAllByHim( + address sender + ) public { + vm.assume(sender != alreadyFollowingProfileOwner); + vm.assume(!followNFT.isApprovedForAll(alreadyFollowingProfileOwner, sender)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.expectRevert(IFollowNFT.DoesNotHavePermissions.selector); + vm.prank(sender); + followNFT.approveFollow(followerProfileId, followTokenId); + } + + function testCannotApproveFollowIfTokenIsUnwrapped() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.expectRevert(IFollowNFT.OnlyWrappedFollowTokens.selector); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + } + + ////////////////////////////////////////////////////////// + // Approve follow - Scenarios + ////////////////////////////////////////////////////////// + + function testApproveFollowWhenTokenIsWrappedAndCallerIsItsOwner() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + } + + function testApproveFollowWhenTokenIsWrappedAndCallerIsApprovedForAllByItsOwner( + address approvedForAll + ) public { + vm.assume(approvedForAll != alreadyFollowingProfileOwner); + vm.assume(approvedForAll != address(0)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.setApprovalForAll(approvedForAll, true); + + vm.prank(approvedForAll); + followNFT.approveFollow(followerProfileId, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + } + + function testFollowApprovalIsClearedAfterUnwrapping() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.unwrap(followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), 0); + + // Wraps again and checks that it keeps being clear. + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + function testFollowApprovalIsClearedAfterTransfer() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.transferFrom(alreadyFollowingProfileOwner, followerProfileOwner, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), 0); + + // Transfers back to previous owner and checks that it keeps being clear. + + vm.prank(followerProfileOwner); + followNFT.transferFrom(followerProfileOwner, alreadyFollowingProfileOwner, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } + + function testFollowApprovalIsClearedAfterBurning() public { + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.approveFollow(followerProfileId, followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), followerProfileId); + + vm.prank(alreadyFollowingProfileOwner); + followNFT.burn(followTokenId); + + assertEq(followNFT.getFollowApproved(followTokenId), 0); + } +} diff --git a/test/foundry/FollowTest.t.sol b/test/foundry/FollowTest.t.sol new file mode 100644 index 0000000..2514177 --- /dev/null +++ b/test/foundry/FollowTest.t.sol @@ -0,0 +1,552 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './MetaTxNegatives.t.sol'; +import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; +import {IFollowNFT} from 'contracts/interfaces/IFollowNFT.sol'; +import '../../contracts/mocks/MockFollowModuleWithRevertFlag.sol'; + +contract FollowTest is BaseTest { + using Strings for uint256; + + uint256 constant MINT_NEW_TOKEN = 0; + + address constant PROFILE_OWNER = address(0); + + uint256 constant targetProfileOwnerPk = 0xC0FFEE; + address targetProfileOwner; + uint256 targetProfileId; + + uint256 constant followerProfileOwnerPk = 0x7357; + address followerProfileOwner; + uint256 followerProfileId; + + uint256 constant alreadyFollowingProfileOwnerPk = 0xF01108; + address alreadyFollowingProfileOwner; + uint256 alreadyFollowingProfileId; + + address targetFollowNFTAddress; + + uint256 followTokenId; + + address followModuleWithRevertFlag; + + function setUp() public virtual override { + super.setUp(); + + targetProfileOwner = vm.addr(targetProfileOwnerPk); + targetProfileId = _createProfile(targetProfileOwner); + + followerProfileOwner = vm.addr(followerProfileOwnerPk); + followerProfileId = _createProfile(followerProfileOwner); + + alreadyFollowingProfileOwner = vm.addr(alreadyFollowingProfileOwnerPk); + alreadyFollowingProfileId = _createProfile(alreadyFollowingProfileOwner); + + followTokenId = _follow( + alreadyFollowingProfileOwner, + alreadyFollowingProfileId, + targetProfileId, + 0, + '' + )[0]; + + targetFollowNFTAddress = hub.getFollowNFT(targetProfileId); + followNFT = FollowNFT(targetFollowNFTAddress); + + followModuleWithRevertFlag = address(new MockFollowModuleWithRevertFlag()); + vm.prank(governance); + hub.whitelistFollowModule(followModuleWithRevertFlag, true); + } + + // Negatives + + function testCannotFollowIfPaused() public { + vm.prank(governance); + hub.setState(DataTypes.ProtocolState.Paused); + + vm.expectRevert(Errors.Paused.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfBlocked() public { + vm.prank(targetProfileOwner); + hub.setBlockStatus(targetProfileId, _toUint256Array(followerProfileId), _toBoolArray(true)); + + vm.expectRevert(Errors.Blocked.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfExecutorIsNotTheProfileOwnerOrHisApprovedExecutor(uint256 executorPk) + public + { + executorPk = bound(executorPk, 1, ISSECP256K1_CURVE_ORDER - 1); + address executor = vm.addr(executorPk); + vm.assume(executor != address(0)); + vm.assume(executor != followerProfileOwner); + vm.assume(!hub.isDelegatedExecutorApproved(followerProfileOwner, executor)); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _follow({ + pk: executorPk, + isFollowerProfileOwner: false, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('', '') + }); + } + + function testCannotFollowWithUnwrappedTokenIfExecutorIsNotTheProfileOwnerOrHisApprovedExecutor( + uint256 executorPk + ) public { + executorPk = bound(executorPk, 1, ISSECP256K1_CURVE_ORDER - 1); + address executor = vm.addr(executorPk); + vm.assume(executor != address(0)); + vm.assume(executor != followerProfileOwner); + vm.assume(!hub.isDelegatedExecutorApproved(followerProfileOwner, executor)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + assertFalse(followNFT.exists(followTokenId)); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _follow({ + pk: executorPk, + isFollowerProfileOwner: false, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(followTokenId), + datas: _toBytesArray('', '') + }); + } + + function testCannotFollowWithWrappedTokenIfExecutorIsNotTheProfileOwnerOrHisApprovedExecutor( + uint256 executorPk + ) public { + executorPk = bound(executorPk, 1, ISSECP256K1_CURVE_ORDER - 1); + address executor = vm.addr(executorPk); + vm.assume(executor != address(0)); + vm.assume(executor != followerProfileOwner); + vm.assume(!hub.isDelegatedExecutorApproved(followerProfileOwner, executor)); + + uint256 followTokenId = followNFT.getFollowTokenId(alreadyFollowingProfileId); + vm.prank(alreadyFollowingProfileOwner); + followNFT.wrap(followTokenId); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _follow({ + pk: executorPk, + isFollowerProfileOwner: false, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(followTokenId), + datas: _toBytesArray('', '') + }); + } + + function testCannotFollowIfAmountOfTokenIdsPassedDiffersFromAmountOfProfilesToFollow() public { + vm.expectRevert(Errors.ArrayMismatch.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId, alreadyFollowingProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('', '') + }); + } + + function testCannotFollowIfAmountOfDataForFollowModulePassedDiffersFromAmountOfProfilesToFollow() + public + { + vm.expectRevert(Errors.ArrayMismatch.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('', '') + }); + } + + function testCannotFollowIfFollowerProfileDoesNotExist() public { + vm.prank(followerProfileOwner); + hub.burn(followerProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfFollowedProfileHaveIdZero() public { + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(0), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfProfileBeingFollowedDoesNotExist() public { + vm.prank(targetProfileOwner); + hub.burn(targetProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfAlreadyFollowing() public { + vm.expectRevert(IFollowNFT.AlreadyFollowing.selector); + + _follow({ + pk: alreadyFollowingProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: alreadyFollowingProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + function testCannotFollowIfFollowModuleRevertsWhileProcessingTheFollow() public { + vm.prank(targetProfileOwner); + hub.setFollowModule(targetProfileId, followModuleWithRevertFlag, ''); + + bool revertWhileProcessingFollow = true; + + vm.expectRevert(MockFollowModuleWithRevertFlag.MockFollowModuleReverted.selector); + + _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray(abi.encode(revertWhileProcessingFollow)) + }); + } + + function testCannotSelfFollow() public { + vm.expectRevert(Errors.SelfFollow.selector); + + _follow({ + pk: targetProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: targetProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray('') + }); + } + + // Positives + + function testFollowAsFollowerOwner() public { + vm.prank(targetProfileOwner); + hub.setFollowModule(targetProfileId, followModuleWithRevertFlag, ''); + + bytes memory followModuleData = abi.encode(false); + + uint256 expectedFollowTokenIdAssigned = followTokenId + 1; + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Followed( + followerProfileId, + targetProfileId, + expectedFollowTokenIdAssigned, + followModuleData, + block.timestamp + ); + + vm.expectCall( + targetFollowNFTAddress, + abi.encodeCall( + followNFT.follow, + (followerProfileId, followerProfileOwner, MINT_NEW_TOKEN) + ) + ); + + vm.expectCall( + followModuleWithRevertFlag, + abi.encodeCall( + IFollowModule.processFollow, + ( + followerProfileId, + MINT_NEW_TOKEN, + followerProfileOwner, + targetProfileId, + followModuleData + ) + ) + ); + + uint256[] memory assignedFollowTokenIds = _follow({ + pk: followerProfileOwnerPk, + isFollowerProfileOwner: true, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray(followModuleData) + }); + + assertEq(assignedFollowTokenIds.length, 1); + assertEq(assignedFollowTokenIds[0], expectedFollowTokenIdAssigned); + assertTrue(hub.isFollowing(followerProfileId, targetProfileId)); + } + + function testFollowAsFollowerApprovedDelegatedExecutor(uint256 approvedDelegatedExecutorPk) + public + { + approvedDelegatedExecutorPk = bound( + approvedDelegatedExecutorPk, + 1, + ISSECP256K1_CURVE_ORDER - 1 + ); + address approvedDelegatedExecutor = vm.addr(approvedDelegatedExecutorPk); + vm.assume(approvedDelegatedExecutor != address(0)); + vm.assume(approvedDelegatedExecutor != followerProfileOwner); + + vm.prank(followerProfileOwner); + hub.setDelegatedExecutorApproval(approvedDelegatedExecutor, true); + + vm.prank(targetProfileOwner); + hub.setFollowModule(targetProfileId, followModuleWithRevertFlag, ''); + + bytes memory followModuleData = abi.encode(false); + + uint256 expectedFollowTokenIdAssigned = followTokenId + 1; + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Followed( + followerProfileId, + targetProfileId, + expectedFollowTokenIdAssigned, + followModuleData, + block.timestamp + ); + + vm.expectCall( + targetFollowNFTAddress, + abi.encodeCall( + followNFT.follow, + (followerProfileId, approvedDelegatedExecutor, MINT_NEW_TOKEN) + ) + ); + + vm.expectCall( + followModuleWithRevertFlag, + abi.encodeCall( + IFollowModule.processFollow, + ( + followerProfileId, + MINT_NEW_TOKEN, + approvedDelegatedExecutor, + targetProfileId, + followModuleData + ) + ) + ); + + uint256[] memory assignedFollowTokenIds = _follow({ + pk: approvedDelegatedExecutorPk, + isFollowerProfileOwner: false, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray(followModuleData) + }); + + assertEq(assignedFollowTokenIds.length, 1); + assertEq(assignedFollowTokenIds[0], expectedFollowTokenIdAssigned); + assertTrue(hub.isFollowing(followerProfileId, targetProfileId)); + } + + function _follow( + uint256 pk, + bool isFollowerProfileOwner, + uint256 followerProfileId, + uint256[] memory idsOfProfilesToFollow, + uint256[] memory followTokenIds, + bytes[] memory datas + ) internal virtual returns (uint256[] memory) { + vm.prank(vm.addr(pk)); + return hub.follow(followerProfileId, idsOfProfilesToFollow, followTokenIds, datas); + } + + function _refreshCachedNonces() internal virtual { + // Nothing to do there. + } +} + +contract FollowMetaTxTest is FollowTest, MetaTxNegatives { + mapping(address => uint256) cachedNonceByAddress; + + function setUp() public override(FollowTest, MetaTxNegatives) { + FollowTest.setUp(); + MetaTxNegatives.setUp(); + + cachedNonceByAddress[followerProfileOwner] = _getSigNonce(followerProfileOwner); + cachedNonceByAddress[alreadyFollowingProfileOwner] = _getSigNonce( + alreadyFollowingProfileOwner + ); + } + + function _follow( + uint256 pk, + bool isFollowerProfileOwner, + uint256 followerProfileId, + uint256[] memory idsOfProfilesToFollow, + uint256[] memory followTokenIds, + bytes[] memory datas + ) internal override returns (uint256[] memory) { + address signer = vm.addr(pk); + return + hub.followWithSig( + _getSignedData({ + signerPk: pk, + delegatedSigner: isFollowerProfileOwner ? PROFILE_OWNER : signer, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: idsOfProfilesToFollow, + followTokenIds: followTokenIds, + datas: datas, + nonce: cachedNonceByAddress[signer], + deadline: type(uint256).max + }) + ); + } + + function _executeMetaTx( + uint256 signerPk, + uint256 nonce, + uint256 deadline + ) internal virtual override { + hub.followWithSig( + _getSignedData({ + signerPk: signerPk, + delegatedSigner: PROFILE_OWNER, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(targetProfileId), + followTokenIds: _toUint256Array(MINT_NEW_TOKEN), + datas: _toBytesArray(''), + nonce: nonce, + deadline: deadline + }) + ); + } + + function _getDefaultMetaTxSignerPk() internal virtual override returns (uint256) { + return followerProfileOwnerPk; + } + + function _calculateFollowWithSigDigest( + uint256 followerProfileId, + uint256[] memory idsOfProfilesToFollow, + uint256[] memory followTokenIds, + bytes[] memory datas, + uint256 nonce, + uint256 deadline + ) internal returns (bytes32) { + bytes32[] memory dataHashes = new bytes32[](datas.length); + for (uint256 i = 0; i < datas.length; ) { + dataHashes[i] = keccak256(datas[i]); + unchecked { + ++i; + } + } + return + _calculateDigest( + keccak256( + abi.encode( + FOLLOW_WITH_SIG_TYPEHASH, + followerProfileId, + keccak256(abi.encodePacked(idsOfProfilesToFollow)), + keccak256(abi.encodePacked(followTokenIds)), + keccak256(abi.encodePacked(dataHashes)), + nonce, + deadline + ) + ) + ); + } + + function _getSignedData( + uint256 signerPk, + address delegatedSigner, + uint256 followerProfileId, + uint256[] memory idsOfProfilesToFollow, + uint256[] memory followTokenIds, + bytes[] memory datas, + uint256 nonce, + uint256 deadline + ) internal returns (DataTypes.FollowWithSigData memory) { + return + DataTypes.FollowWithSigData({ + delegatedSigner: delegatedSigner, + followerProfileId: followerProfileId, + idsOfProfilesToFollow: idsOfProfilesToFollow, + followTokenIds: followTokenIds, + datas: datas, + sig: _getSigStruct({ + pKey: signerPk, + digest: _calculateFollowWithSigDigest( + followerProfileId, + idsOfProfilesToFollow, + followTokenIds, + datas, + nonce, + deadline + ), + deadline: deadline + }) + }); + } + + function _refreshCachedNonces() internal override { + cachedNonceByAddress[followerProfileOwner] = _getSigNonce(followerProfileOwner); + cachedNonceByAddress[alreadyFollowingProfileOwner] = _getSigNonce( + alreadyFollowingProfileOwner + ); + } +} diff --git a/test/foundry/GovernanceFunctions.t.sol b/test/foundry/GovernanceFunctions.t.sol new file mode 100644 index 0000000..f6bfa97 --- /dev/null +++ b/test/foundry/GovernanceFunctions.t.sol @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; + +contract GovernanceFunctionsTest is BaseTest { + function setUp() public virtual override { + TestSetup.setUp(); + } + + // NEGATIVES + + function testUserCannotCallGovernanceFunctions() public { + vm.startPrank(profileOwner); + + vm.expectRevert(Errors.NotGovernance.selector); + hub.setGovernance(profileOwner); + + vm.expectRevert(Errors.NotGovernance.selector); + hub.whitelistFollowModule(profileOwner, true); + + vm.expectRevert(Errors.NotGovernance.selector); + hub.whitelistReferenceModule(profileOwner, true); + + vm.expectRevert(Errors.NotGovernance.selector); + hub.whitelistCollectModule(profileOwner, true); + + vm.stopPrank(); + } + + // SCENARIOS + + function testGovernanceCanWhitelistAndUnwhitelistModules() public { + vm.startPrank(governance); + + // Whitelist + + assertEq(hub.isFollowModuleWhitelisted(profileOwner), false); + hub.whitelistFollowModule(profileOwner, true); + assertEq(hub.isFollowModuleWhitelisted(profileOwner), true); + + assertEq(hub.isReferenceModuleWhitelisted(profileOwner), false); + hub.whitelistReferenceModule(profileOwner, true); + assertEq(hub.isReferenceModuleWhitelisted(profileOwner), true); + + assertEq(hub.isCollectModuleWhitelisted(profileOwner), false); + hub.whitelistCollectModule(profileOwner, true); + assertEq(hub.isCollectModuleWhitelisted(profileOwner), true); + + // Unwhitelist + + hub.whitelistFollowModule(profileOwner, false); + assertEq(hub.isFollowModuleWhitelisted(profileOwner), false); + + hub.whitelistReferenceModule(profileOwner, false); + assertEq(hub.isReferenceModuleWhitelisted(profileOwner), false); + + hub.whitelistCollectModule(profileOwner, false); + assertEq(hub.isCollectModuleWhitelisted(profileOwner), false); + + vm.stopPrank(); + } + + function testGovernanceCanChangeGovernanceAddress() public { + vm.startPrank(governance); + + assertEq(hub.getGovernance(), governance); + hub.setGovernance(profileOwner); + assertEq(hub.getGovernance(), profileOwner); + + vm.stopPrank(); + } +} diff --git a/test/foundry/MetaTxNegatives.t.sol b/test/foundry/MetaTxNegatives.t.sol new file mode 100644 index 0000000..0184f05 --- /dev/null +++ b/test/foundry/MetaTxNegatives.t.sol @@ -0,0 +1,169 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; + +abstract contract MetaTxNegatives is BaseTest { + uint256 private constant NO_DEADLINE = type(uint256).max; + uint256 private _defaultMetaTxSignerPk; + address private _defaultMetaTxSigner; + uint256 private _defaultMetaTxSignerNonce; + + function setUp() public virtual override { + _defaultMetaTxSignerPk = _getDefaultMetaTxSignerPk(); + _defaultMetaTxSigner = vm.addr(_defaultMetaTxSignerPk); + _defaultMetaTxSignerNonce = _getMetaTxNonce(_defaultMetaTxSigner); + } + + // Functions to mandatorily override. + + function _executeMetaTx( + uint256 signerPk, + uint256 nonce, + uint256 deadline + ) internal virtual; + + function _getDefaultMetaTxSignerPk() internal virtual returns (uint256); + + // Functions to override ONLY if the contract where to execute the MetaTx is not the LensHub. + + function _getMetaTxNonce(address signer) internal virtual returns (uint256) { + return _getSigNonce(signer); + } + + function _getDomainName() internal virtual returns (bytes memory) { + return bytes('Lens Protocol Profiles'); + } + + function _getRevisionNumber() internal virtual returns (bytes memory) { + return bytes('1'); + } + + function _getVerifyingContract() internal virtual returns (address) { + return hubProxyAddr; + } + + // Functions for MetaTx Negative test cases. + + function testCannotExecuteMetaTxWhenSignatureHasExpired() public { + domainSeparator = _getValidDomainSeparator(); + uint256 expiredTimestamp = block.timestamp; + uint256 mockTimestamp = expiredTimestamp + 69; + vm.warp(mockTimestamp); + vm.expectRevert(Errors.SignatureExpired.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce, + deadline: expiredTimestamp + }); + } + + function testCannotExecuteMetaTxWhenSignatureNonceIsInvalid() public { + domainSeparator = _getValidDomainSeparator(); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce + 69, + deadline: NO_DEADLINE + }); + } + + function testCannotExecuteMetaTxWhenSignatureSignerIsInvalid() public { + domainSeparator = _getValidDomainSeparator(); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: 1234569696969, + nonce: _defaultMetaTxSignerNonce, + deadline: NO_DEADLINE + }); + } + + function testCannotExecuteMetaTxWhenSignatureDomainWasGeneratedWithWrongRevisionNumber() + public + { + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(_getDomainName()), + keccak256('69696969696969696969696969969696'), + block.chainid, + _getVerifyingContract() + ) + ); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce, + deadline: NO_DEADLINE + }); + } + + function testCannotExecuteMetaTxWhenSignatureDomainWasGeneratedWithWrongChainId() public { + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(_getDomainName()), + keccak256(_getRevisionNumber()), + type(uint256).max, + _getVerifyingContract() + ) + ); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce, + deadline: NO_DEADLINE + }); + } + + function testCannotExecuteMetaTxWhenSignatureDomainWasGeneratedWithWrongVerifyingContract() + public + { + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(_getDomainName()), + keccak256(_getRevisionNumber()), + block.chainid, + address(0x691234569696969) + ) + ); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce, + deadline: NO_DEADLINE + }); + } + + function testCannotExecuteMetaTxWhenSignatureDomainWasGeneratedWithWrongName() public { + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256('This should be an invalid name :)'), + keccak256(_getRevisionNumber()), + block.chainid, + _getVerifyingContract() + ) + ); + vm.expectRevert(Errors.SignatureInvalid.selector); + _executeMetaTx({ + signerPk: _defaultMetaTxSignerPk, + nonce: _defaultMetaTxSignerNonce, + deadline: NO_DEADLINE + }); + } + + function _getValidDomainSeparator() internal virtual returns (bytes32) { + return + keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(_getDomainName()), + keccak256(_getRevisionNumber()), + block.chainid, + _getVerifyingContract() + ) + ); + } +} diff --git a/test/foundry/Misc.t.sol b/test/foundry/Misc.t.sol new file mode 100644 index 0000000..1dd2999 --- /dev/null +++ b/test/foundry/Misc.t.sol @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import '../../contracts/mocks/MockFollowModule.sol'; + +// Original Misc +contract NFTTransferEmittersTest is BaseTest { + // Negatives + function testCannotEmitFollowNFTTransferEvent() public { + vm.expectRevert(Errors.CallerNotFollowNFT.selector); + hub.emitFollowNFTTransferEvent(newProfileId, 1, profileOwner, otherSigner); + } + + function testCannotEmitCollectNFTTransferEvent() public { + vm.expectRevert(Errors.CallerNotCollectNFT.selector); + hub.emitCollectNFTTransferEvent(newProfileId, 1, 1, profileOwner, otherSigner); + } +} + +// New Misc +contract MiscTest is BaseTest { + // Negatives + function testSetDefaultProfileNotExecutorFails() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setDefaultProfile(profileOwner, newProfileId); + } + + function testSetProfileImageURINotExecutorFails() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setProfileImageURI(newProfileId, MOCK_URI); + } + + function testSetFollowNFTURINotExecutorFails() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setFollowNFTURI(newProfileId, MOCK_URI); + } + + // Positives + function testExecutorSetDefaultProfile() public { + assertEq(hub.getDefaultProfile(profileOwner), 0); + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + vm.prank(otherSigner); + hub.setDefaultProfile(profileOwner, newProfileId); + assertEq(hub.getDefaultProfile(profileOwner), newProfileId); + } + + function testExecutorSetProfileImageURI() public { + assertEq(hub.getProfileImageURI(newProfileId), MOCK_URI); + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + vm.prank(otherSigner); + hub.setProfileImageURI(newProfileId, 'test'); + assertEq(hub.getProfileImageURI(newProfileId), 'test'); + } + + function testExecutorSetFollowNFTURI() public { + assertEq(hub.getFollowNFTURI(newProfileId), MOCK_URI); + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + vm.prank(otherSigner); + hub.setFollowNFTURI(newProfileId, 'test'); + assertEq(hub.getFollowNFTURI(newProfileId), 'test'); + } + + // Meta-tx + // Negatives + function testSetDefaultProfileWithSigInvalidSignerFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetDefaultProfileTypedDataHash( + profileOwner, + newProfileId, + nonce, + deadline + ); + + vm.expectRevert(Errors.SignatureInvalid.selector); + hub.setDefaultProfileWithSig( + DataTypes.SetDefaultProfileWithSigData({ + delegatedSigner: address(0), + wallet: profileOwner, + profileId: newProfileId, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function testSetDefaultProfileWithSigNotExecutorFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetDefaultProfileTypedDataHash( + profileOwner, + newProfileId, + nonce, + deadline + ); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setDefaultProfileWithSig( + DataTypes.SetDefaultProfileWithSigData({ + delegatedSigner: otherSigner, + wallet: profileOwner, + profileId: newProfileId, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function testSetProfileImageURIWithSigInvalidSignerFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetProfileImageURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + vm.expectRevert(Errors.SignatureInvalid.selector); + hub.setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + imageURI: MOCK_URI, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function testSetProfileImageURIWithSigNotExecutorFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetProfileImageURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: otherSigner, + profileId: newProfileId, + imageURI: MOCK_URI, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function testSetFollowNFTURIWithSigInvalidSignerFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, MOCK_URI, nonce, deadline); + + vm.expectRevert(Errors.SignatureInvalid.selector); + hub.setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followNFTURI: MOCK_URI, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function testSetFollowNFTURIWithSigNotExecutorFails() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, MOCK_URI, nonce, deadline); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: otherSigner, + profileId: newProfileId, + followNFTURI: MOCK_URI, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + // Postivies + function testSetDefaultProfileWithSig() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetDefaultProfileTypedDataHash( + profileOwner, + newProfileId, + nonce, + deadline + ); + + assertEq(hub.getDefaultProfile(profileOwner), 0); + hub.setDefaultProfileWithSig( + DataTypes.SetDefaultProfileWithSigData({ + delegatedSigner: address(0), + wallet: profileOwner, + profileId: newProfileId, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + assertEq(hub.getDefaultProfile(profileOwner), newProfileId); + } + + function testExecutorSetDefaultProfileWithSig() public { + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetDefaultProfileTypedDataHash( + profileOwner, + newProfileId, + nonce, + deadline + ); + + assertEq(hub.getDefaultProfile(profileOwner), 0); + hub.setDefaultProfileWithSig( + DataTypes.SetDefaultProfileWithSigData({ + delegatedSigner: otherSigner, + wallet: profileOwner, + profileId: newProfileId, + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + assertEq(hub.getDefaultProfile(profileOwner), newProfileId); + } + + function testSetProfileImageURIWithSig() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetProfileImageURITypedDataHash(newProfileId, 'test', nonce, deadline); + + assertEq(hub.getProfileImageURI(newProfileId), MOCK_URI); + hub.setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + imageURI: 'test', + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + assertEq(hub.getProfileImageURI(newProfileId), 'test'); + } + + function testExecutorSetProfileImageURIWithSig() public { + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetProfileImageURITypedDataHash(newProfileId, 'test', nonce, deadline); + + assertEq(hub.getProfileImageURI(newProfileId), MOCK_URI); + hub.setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: otherSigner, + profileId: newProfileId, + imageURI: 'test', + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + assertEq(hub.getProfileImageURI(newProfileId), 'test'); + } + + function testSetFollowNFTURIWithSig() public { + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, 'test', nonce, deadline); + + assertEq(hub.getFollowNFTURI(newProfileId), MOCK_URI); + hub.setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followNFTURI: 'test', + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + assertEq(hub.getFollowNFTURI(newProfileId), 'test'); + } + + function testExecutorSetFollowNFTURIWithSig() public { + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + uint256 nonce = 0; + uint256 deadline = type(uint256).max; + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, 'test', nonce, deadline); + + assertEq(hub.getFollowNFTURI(newProfileId), MOCK_URI); + hub.setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: otherSigner, + profileId: newProfileId, + followNFTURI: 'test', + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + assertEq(hub.getFollowNFTURI(newProfileId), 'test'); + } +} diff --git a/test/foundry/ModuleGlobals.t.sol b/test/foundry/ModuleGlobals.t.sol new file mode 100644 index 0000000..0537376 --- /dev/null +++ b/test/foundry/ModuleGlobals.t.sol @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; + +contract ModuleGlobalsTest is BaseTest { + function setUp() public override { + super.setUp(); + assertFalse(me == hub.getGovernance(), 'address(this) should not be governance'); + } + + // Negatives - non Gov caller + function testCannotSetGovernanceAddress_ifNotGovernance() public { + vm.expectRevert(Errors.NotGovernance.selector); + moduleGlobals.setGovernance(address(42)); + } + + function testCannotSetTreasuryAddress_ifNotGovernance() public { + vm.expectRevert(Errors.NotGovernance.selector); + moduleGlobals.setTreasury(address(42)); + } + + function testCannotSetTreasuryFee_ifNotGovernance() public { + vm.expectRevert(Errors.NotGovernance.selector); + moduleGlobals.setTreasuryFee(0); + } + + // Negatives - Gov caller + function testCannotSetGovernanceToZeroAddress() public { + vm.prank(governance); + vm.expectRevert(Errors.InitParamsInvalid.selector); + moduleGlobals.setGovernance(address(0)); + } + + function testCannotSetTreasuryToZeroAddress() public { + vm.prank(governance); + vm.expectRevert(Errors.InitParamsInvalid.selector); + moduleGlobals.setTreasury(address(0)); + } + + function testCannotWhitelistZeroAddressAsCurrency() public { + vm.prank(governance); + vm.expectRevert(Errors.InitParamsInvalid.selector); + moduleGlobals.whitelistCurrency(address(0), true); + } + + function testCannotSetTreasuryFee_largerOrEqualThanHalfOfBPS_MAX() public { + vm.prank(governance); + vm.expectRevert(Errors.InitParamsInvalid.selector); + moduleGlobals.setTreasuryFee(TREASURY_FEE_MAX_BPS / 2); + } + + // Scenarios + function testSetGovernanceAddress_ifGovernance() public { + address governanceBefore = moduleGlobals.getGovernance(); + address newGovernance = address(uint160(governanceBefore) + 1); + + assertEq(governanceBefore, governance, 'ModuleGlobals Governance is not Governance'); + + vm.prank(governance); + moduleGlobals.setGovernance(newGovernance); + + address governanceAfter = moduleGlobals.getGovernance(); + + assertEq( + governanceAfter, + newGovernance, + "ModuleGlobals Governance didn't change to newGovernance" + ); + assertFalse(governanceBefore == governanceAfter, "ModuleGlobals Governance didn't change"); + } + + function testSetTreasuryAddress_ifGovernance() public { + address treasuryBefore = moduleGlobals.getTreasury(); + address newTreasury = address(uint160(treasuryBefore) + 1); + + vm.prank(governance); + moduleGlobals.setTreasury(newTreasury); + + address treasuryAfter = moduleGlobals.getTreasury(); + + assertEq(treasuryAfter, newTreasury, "ModuleGlobals Treasury didn't change to newTreasury"); + assertFalse(treasuryBefore == treasuryAfter, "ModuleGlobals Treasury didn't change"); + } + + function testSetTreasuryFee_ifGovernance() public { + uint16 treasuryFeeBefore = moduleGlobals.getTreasuryFee(); + uint16 newTreasuryFee = treasuryFeeBefore + 1; + if (newTreasuryFee == TREASURY_FEE_MAX_BPS / 2) newTreasuryFee = 0; + + vm.prank(governance); + moduleGlobals.setTreasuryFee(newTreasuryFee); + + uint16 treasuryFeeAfter = moduleGlobals.getTreasuryFee(); + + assertEq( + treasuryFeeAfter, + newTreasuryFee, + "ModuleGlobals TreasuryFee didn't change to newTreasuryFee" + ); + assertFalse( + treasuryFeeBefore == treasuryFeeAfter, + "ModuleGlobals TreasuryFee didn't change" + ); + } + + function testGetGovernance() public { + vm.prank(governance); + moduleGlobals.setGovernance(address(42)); + assertEq( + moduleGlobals.getGovernance(), + address(42), + 'ModuleGlobals Governance does not match set value' + ); + } + + function testGetTreasury() public { + vm.prank(governance); + moduleGlobals.setTreasury(address(42)); + assertEq( + moduleGlobals.getTreasury(), + address(42), + 'ModuleGlobals Treasury does not match set value' + ); + } + + function testGetTreasuryFee() public { + vm.prank(governance); + moduleGlobals.setTreasuryFee(42); + assertEq( + moduleGlobals.getTreasuryFee(), + 42, + 'ModuleGlobals TreasuryFee does not match set value' + ); + } +} diff --git a/test/foundry/MultiStateHubTest.t.sol b/test/foundry/MultiStateHubTest.t.sol new file mode 100644 index 0000000..88fe7a3 --- /dev/null +++ b/test/foundry/MultiStateHubTest.t.sol @@ -0,0 +1,818 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './helpers/SignatureHelpers.sol'; + +contract MultiStateHubTest_Common is BaseTest { + // Negatives + function testCannotSetStateAsRegularUser() public { + vm.expectRevert(Errors.NotGovernanceOrEmergencyAdmin.selector); + _setState(DataTypes.ProtocolState.Paused); + + vm.expectRevert(Errors.NotGovernanceOrEmergencyAdmin.selector); + _setState(DataTypes.ProtocolState.PublishingPaused); + + vm.expectRevert(Errors.NotGovernanceOrEmergencyAdmin.selector); + _setState(DataTypes.ProtocolState.Unpaused); + } + + function testCannotSetEmergencyAdminAsRegularUser() public { + vm.expectRevert(Errors.NotGovernance.selector); + _setEmergencyAdmin(address(this)); + } + + function testCannotUnpauseAsEmergencyAdmin() public { + vm.prank(governance); + _setEmergencyAdmin(address(this)); + + vm.expectRevert(Errors.EmergencyAdminCanOnlyPauseFurther.selector); + _setState(DataTypes.ProtocolState.Unpaused); + } + + function testCannotSetLowerStateAsEmergencyAdmin() public { + vm.prank(governance); + _setEmergencyAdmin(address(this)); + + _setState(DataTypes.ProtocolState.Paused); + + vm.expectRevert(Errors.EmergencyAdminCanOnlyPauseFurther.selector); + _setState(DataTypes.ProtocolState.PublishingPaused); + + vm.expectRevert(Errors.EmergencyAdminCanOnlyPauseFurther.selector); + _setState(DataTypes.ProtocolState.Paused); + } + + function testCannotSetEmergencyAdminAsEmergencyAdmin() public { + vm.prank(governance); + _setEmergencyAdmin(address(this)); + + vm.expectRevert(Errors.NotGovernance.selector); + _setEmergencyAdmin(address(0)); + } + + // Scenarios + function testSetProtocolStateAsEmergencyAdmin() public { + vm.prank(governance); + _setEmergencyAdmin(address(this)); + + DataTypes.ProtocolState[2] memory states = [ + DataTypes.ProtocolState.PublishingPaused, + DataTypes.ProtocolState.Paused + ]; + + for (uint256 i = 0; i < states.length; i++) { + DataTypes.ProtocolState newState = states[i]; + DataTypes.ProtocolState prevState = _getState(); + _setState(newState); + DataTypes.ProtocolState curState = _getState(); + assertTrue(newState == curState); + assertTrue(curState != prevState); + } + } + + function testSetProtocolStateAsGovernance() public { + vm.startPrank(governance); + + DataTypes.ProtocolState[6] memory states = [ + DataTypes.ProtocolState.PublishingPaused, + DataTypes.ProtocolState.Paused, + DataTypes.ProtocolState.Unpaused, + DataTypes.ProtocolState.Paused, + DataTypes.ProtocolState.PublishingPaused, + DataTypes.ProtocolState.Unpaused + ]; + + for (uint256 i = 0; i < states.length; i++) { + DataTypes.ProtocolState newState = states[i]; + DataTypes.ProtocolState prevState = _getState(); + _setState(newState); + DataTypes.ProtocolState curState = _getState(); + assertTrue(newState == curState); + assertTrue(curState != prevState); + } + vm.stopPrank(); + } + + function testGovernanceCanRevokeEmergencyAdmin() public { + vm.prank(governance); + _setEmergencyAdmin(address(this)); + + _setState(DataTypes.ProtocolState.PublishingPaused); + + vm.prank(governance); + _setEmergencyAdmin(address(0)); + + vm.expectRevert(Errors.NotGovernanceOrEmergencyAdmin.selector); + _setState(DataTypes.ProtocolState.Paused); + } +} + +contract MultiStateHubTest_PausedState_Direct is BaseTest { + uint256 postId; + uint256 followerProfileId; + + function setUp() public virtual override { + super.setUp(); + + followerProfileId = _createProfile(me); + + vm.prank(profileOwner); + postId = _post(mockPostData); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Paused); + } + + // TODO: Consider extracting these mock actions functions somewhere because they're used in several places + function _mockSetFollowModule() internal virtual { + _setFollowModule(profileOwner, newProfileId, address(0), ''); + } + + function _mockSetDelegatedExecutorApproval() internal virtual { + address executor = otherSigner; + bool approved = true; + _setDelegatedExecutorApproval(profileOwner, executor, approved); + } + + function _mockSetProfileImageURI() internal virtual { + _setProfileImageURI(profileOwner, newProfileId, MOCK_URI); + } + + function _mockSetFollowNFTURI() internal virtual { + _setFollowNFTURI(profileOwner, newProfileId, MOCK_URI); + } + + function _mockPost() internal virtual { + vm.prank(profileOwner); + _post(mockPostData); + } + + function _mockComment() internal virtual { + mockCommentData.pubIdPointed = postId; + vm.prank(profileOwner); + _comment(mockCommentData); + } + + function _mockMirror() internal virtual { + mockMirrorData.pubIdPointed = postId; + vm.prank(profileOwner); + _mirror(mockMirrorData); + } + + function _mockBurn() internal virtual { + _burn(profileOwner, newProfileId); + } + + function _mockFollow() internal virtual { + _follow({ + msgSender: me, + followerProfileId: followerProfileId, + idOfProfileToFollow: newProfileId, + followTokenId: 0, + data: '' + }); + } + + // TODO: The following two functions were copy-pasted from CollectingTest.t.sol + // TODO: Consider extracting them somewhere else to be used by both of tests + function _mockCollect() internal virtual { + vm.prank(profileOwner); + _collect( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data + ); + } + + // Negatives + function testCannotTransferProfileWhilePaused() public virtual { + vm.expectRevert(Errors.Paused.selector); + _transferProfile({ + msgSender: profileOwner, + from: profileOwner, + to: address(111), + tokenId: newProfileId + }); + } + + function testCannotCreateProfileWhilePaused() public virtual { + vm.expectRevert(Errors.Paused.selector); + _createProfile(address(this)); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _createProfile(address(this)); + } + + function testCannotSetFollowModuleWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockSetFollowModule(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockSetFollowModule(); + } + + function testCannotSetDelegatedExecutorWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockSetDelegatedExecutorApproval(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockSetDelegatedExecutorApproval(); + } + + function testCannotSetProfileImageURIWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockSetProfileImageURI(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockSetProfileImageURI(); + } + + function testCannotSetFollowNFTURIWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockSetFollowNFTURI(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockSetFollowNFTURI(); + } + + function testCannotPostWhilePaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockPost(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockPost(); + } + + function testCannotCommentWhilePaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockComment(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockComment(); + } + + function testCannotMirrorWhilePaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockMirror(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockMirror(); + } + + function testCannotBurnWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockBurn(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockBurn(); + } + + function testCannotFollowWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockFollow(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockFollow(); + } + + function testCannotCollectWhilePaused() public { + vm.expectRevert(Errors.Paused.selector); + _mockCollect(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockCollect(); + } +} + +contract MultiStateHubTest_PausedState_WithSig is + MultiStateHubTest_PausedState_Direct, + SignatureHelpers, + SigSetup +{ + function setUp() public override(MultiStateHubTest_PausedState_Direct, SigSetup) { + MultiStateHubTest_PausedState_Direct.setUp(); + SigSetup.setUp(); + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + followerProfileId = _createProfile(otherSigner); + vm.prank(governance); + _setState(DataTypes.ProtocolState.Paused); + } + + function _mockSetFollowModule() internal override { + bytes32 digest = _getSetFollowModuleTypedDataHash( + newProfileId, + address(0), + '', + nonce, + deadline + ); + + _setFollowModuleWithSig( + DataTypes.SetFollowModuleWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followModule: address(0), + followModuleInitData: '', + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + // Positives + function _mockSetDelegatedExecutorApproval() internal override { + address onBehalfOf = profileOwner; + address executor = otherSigner; + + bytes32 digest = _getSetDelegatedExecutorApprovalTypedDataHash({ + onBehalfOf: onBehalfOf, + executor: executor, + approved: true, + nonce: nonce, + deadline: deadline + }); + hub.setDelegatedExecutorApprovalWithSig( + _buildSetDelegatedExecutorApprovalWithSigData({ + onBehalfOf: onBehalfOf, + executor: executor, + approved: true, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockSetProfileImageURI() internal override { + bytes32 digest = _getSetProfileImageURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + _setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + imageURI: MOCK_URI, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockSetFollowNFTURI() internal override { + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, MOCK_URI, nonce, deadline); + + _setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followNFTURI: MOCK_URI, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockPost() internal override { + bytes32 digest = _getPostTypedDataHash(mockPostData, nonce, deadline); + + _postWithSig( + _buildPostWithSigData({ + delegatedSigner: address(0), + postData: mockPostData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockComment() internal override { + mockCommentData.pubIdPointed = postId; + bytes32 digest = _getCommentTypedDataHash(mockCommentData, nonce, deadline); + + _commentWithSig( + _buildCommentWithSigData({ + delegatedSigner: address(0), + commentData: mockCommentData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockMirror() internal override { + mockMirrorData.pubIdPointed = postId; + bytes32 digest = _getMirrorTypedDataHash(mockMirrorData, nonce, deadline); + + _mirrorWithSig( + _buildMirrorWithSigData({ + delegatedSigner: address(0), + mirrorData: mockMirrorData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockBurn() internal override { + bytes32 digest = _getBurnTypedDataHash(newProfileId, nonce, deadline); + + _burnWithSig({ + profileId: newProfileId, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }); + } + + function _mockFollow() internal override { + bytes32 digest = _getFollowTypedDataHash( + followerProfileId, + _toUint256Array(newProfileId), + _toUint256Array(0), + _toBytesArray(''), + nonce, + deadline + ); + + _followWithSig( + DataTypes.FollowWithSigData({ + delegatedSigner: address(0), + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(newProfileId), + followTokenIds: _toUint256Array(0), + datas: _toBytesArray(''), + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function _mockCollect() internal override { + bytes32 digest = _getCollectTypedDataHash( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data, + nonce, + deadline + ); + + _collectWithSig( + _buildCollectWithSigData({ + delegatedSigner: address(0), + collectData: mockCollectData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + // Methods that cannot be called with sig + function testCannotTransferProfileWhilePaused() public override {} + + function testCannotCreateProfileWhilePaused() public override {} +} + +contract MultiStateHubTest_PublishingPausedState_Direct is BaseTest { + uint256 postId; + + function setUp() public virtual override { + super.setUp(); + + vm.prank(profileOwner); + postId = _post(mockPostData); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.PublishingPaused); + } + + // TODO: Consider extracting these mock actions functions somewhere because they're used in several places + function _mockSetFollowModule() internal virtual { + _setFollowModule(profileOwner, newProfileId, address(0), ''); + } + + function _mockSetDelegatedExecutorApproval() internal virtual { + address executor = otherSigner; + bool approved = true; + _setDelegatedExecutorApproval(profileOwner, executor, approved); + } + + function _mockSetProfileImageURI() internal virtual { + _setProfileImageURI(profileOwner, newProfileId, MOCK_URI); + } + + function _mockSetFollowNFTURI() internal virtual { + _setFollowNFTURI(profileOwner, newProfileId, MOCK_URI); + } + + function _mockPost() internal virtual { + vm.prank(profileOwner); + _post(mockPostData); + } + + function _mockComment() internal virtual { + mockCommentData.pubIdPointed = postId; + vm.prank(profileOwner); + _comment(mockCommentData); + } + + function _mockMirror() internal virtual { + mockMirrorData.pubIdPointed = postId; + vm.prank(profileOwner); + _mirror(mockMirrorData); + } + + function _mockBurn() internal virtual { + _burn(profileOwner, newProfileId); + } + + function _mockFollow() internal virtual { + _follow({ + msgSender: me, + followerProfileId: _createProfile(me), + idOfProfileToFollow: newProfileId, + followTokenId: 0, + data: '' + }); + } + + // TODO: The following two functions were copy-pasted from CollectingTest.t.sol + // TODO: Consider extracting them somewhere else to be used by both of tests + function _mockCollect() internal virtual { + vm.prank(profileOwner); + _collect( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data + ); + } + + // Negatives + function testCanTransferProfileWhilePublishingPaused() public virtual { + _transferProfile({ + msgSender: profileOwner, + from: profileOwner, + to: address(111), + tokenId: newProfileId + }); + } + + function testCanCreateProfileWhilePublishingPaused() public virtual { + _createProfile(address(this)); + } + + function testCanSetFollowModuleWhilePublishingPaused() public { + _mockSetFollowModule(); + } + + function testCanSetDelegatedExecutorWhilePublishingPaused() public { + _mockSetDelegatedExecutorApproval(); + } + + function testCanSetProfileImageURIWhilePublishingPaused() public { + _mockSetProfileImageURI(); + } + + function testCanSetFollowNFTURIWhilePublishingPaused() public { + _mockSetFollowNFTURI(); + } + + function testCanBurnWhilePublishingPaused() public { + _mockBurn(); + } + + function testCanFollowWhilePublishingPaused() public { + _mockFollow(); + } + + function testCanCollectWhilePublishingPaused() public { + _mockCollect(); + } + + function testCannotPostWhilePublishingPaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockPost(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockPost(); + } + + function testCannotCommentWhilePublishingPaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockComment(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockComment(); + } + + function testCannotMirrorWhilePublishingPaused() public { + vm.expectRevert(Errors.PublishingPaused.selector); + _mockMirror(); + + vm.prank(governance); + _setState(DataTypes.ProtocolState.Unpaused); + + _mockMirror(); + } +} + +contract MultiStateHubTest_PublishingPausedState_WithSig is + MultiStateHubTest_PublishingPausedState_Direct, + SignatureHelpers, + SigSetup +{ + // TODO: Consider refactoring this contract somehow cause it's all just pure copy-paste of the PausedState_WithSig + function setUp() public override(MultiStateHubTest_PublishingPausedState_Direct, SigSetup) { + MultiStateHubTest_PublishingPausedState_Direct.setUp(); + SigSetup.setUp(); + } + + function _mockSetFollowModule() internal override { + bytes32 digest = _getSetFollowModuleTypedDataHash( + newProfileId, + address(0), + '', + nonce, + deadline + ); + + _setFollowModuleWithSig( + DataTypes.SetFollowModuleWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followModule: address(0), + followModuleInitData: '', + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + // Positives + function _mockSetDelegatedExecutorApproval() internal override { + address onBehalfOf = profileOwner; + address executor = otherSigner; + + bytes32 digest = _getSetDelegatedExecutorApprovalTypedDataHash({ + onBehalfOf: onBehalfOf, + executor: executor, + approved: true, + nonce: nonce, + deadline: deadline + }); + hub.setDelegatedExecutorApprovalWithSig( + _buildSetDelegatedExecutorApprovalWithSigData({ + onBehalfOf: onBehalfOf, + executor: executor, + approved: true, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockSetProfileImageURI() internal override { + bytes32 digest = _getSetProfileImageURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + _setProfileImageURIWithSig( + DataTypes.SetProfileImageURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + imageURI: MOCK_URI, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockSetFollowNFTURI() internal override { + bytes32 digest = _getSetFollowNFTURITypedDataHash(newProfileId, MOCK_URI, nonce, deadline); + + _setFollowNFTURIWithSig( + DataTypes.SetFollowNFTURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followNFTURI: MOCK_URI, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockPost() internal override { + bytes32 digest = _getPostTypedDataHash(mockPostData, nonce, deadline); + + _postWithSig( + _buildPostWithSigData({ + delegatedSigner: address(0), + postData: mockPostData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockComment() internal override { + mockCommentData.pubIdPointed = postId; + bytes32 digest = _getCommentTypedDataHash(mockCommentData, nonce, deadline); + + _commentWithSig( + _buildCommentWithSigData({ + delegatedSigner: address(0), + commentData: mockCommentData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockMirror() internal override { + mockMirrorData.pubIdPointed = postId; + bytes32 digest = _getMirrorTypedDataHash(mockMirrorData, nonce, deadline); + + _mirrorWithSig( + _buildMirrorWithSigData({ + delegatedSigner: address(0), + mirrorData: mockMirrorData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function _mockBurn() internal override { + bytes32 digest = _getBurnTypedDataHash(newProfileId, nonce, deadline); + + _burnWithSig({ + profileId: newProfileId, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }); + } + + function _mockFollow() internal override { + uint256 followerProfileId = _createProfile(otherSigner); + bytes32 digest = _getFollowTypedDataHash( + followerProfileId, + _toUint256Array(newProfileId), + _toUint256Array(0), + _toBytesArray(''), + nonce, + deadline + ); + + _followWithSig( + DataTypes.FollowWithSigData({ + delegatedSigner: address(0), + followerProfileId: followerProfileId, + idsOfProfilesToFollow: _toUint256Array(newProfileId), + followTokenIds: _toUint256Array(0), + datas: _toBytesArray(''), + sig: _getSigStruct(otherSignerKey, digest, deadline) + }) + ); + } + + function _mockCollect() internal override { + bytes32 digest = _getCollectTypedDataHash( + mockCollectData.collectorProfileId, + mockCollectData.publisherProfileId, + mockCollectData.pubId, + mockCollectData.data, + nonce, + deadline + ); + + _collectWithSig( + _buildCollectWithSigData({ + delegatedSigner: address(0), + collectData: mockCollectData, + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + // Methods that cannot be called with sig + function testCanTransferProfileWhilePublishingPaused() public override {} + + function testCanCreateProfileWhilePublishingPaused() public override {} +} diff --git a/test/foundry/ProfileMetadataURI.t.sol b/test/foundry/ProfileMetadataURI.t.sol new file mode 100644 index 0000000..05b7b8a --- /dev/null +++ b/test/foundry/ProfileMetadataURI.t.sol @@ -0,0 +1,137 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './MetaTxNegatives.t.sol'; +import {Events} from 'contracts/libraries/Events.sol'; + +contract ProfileMetadataURITest is BaseTest { + function _setProfileMetadataURI( + uint256 pk, + uint256 profileId, + string memory metadataURI + ) internal virtual { + vm.prank(vm.addr(pk)); + hub.setProfileMetadataURI(profileId, metadataURI); + } + + // Negatives + function testCannotSetProfileMetadataURINotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _setProfileMetadataURI({ + pk: alienSignerKey, + profileId: newProfileId, + metadataURI: MOCK_URI + }); + } + + // Positives + function testExecutorSetProfileMetadataURI() public { + assertEq(hub.getProfileMetadataURI(newProfileId), ''); + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + _setProfileMetadataURI({ + pk: otherSignerKey, + profileId: newProfileId, + metadataURI: MOCK_URI + }); + assertEq(hub.getProfileMetadataURI(newProfileId), MOCK_URI); + } + + function testSetProfileMetadataURI() public { + assertEq(hub.getProfileMetadataURI(newProfileId), ''); + + _setProfileMetadataURI({ + pk: profileOwnerKey, + profileId: newProfileId, + metadataURI: MOCK_URI + }); + assertEq(hub.getProfileMetadataURI(newProfileId), MOCK_URI); + } + + // Events + function expectProfileMetadataSetEvent() public { + vm.expectEmit(true, true, true, true, address(hub)); + emit Events.ProfileMetadataSet({ + profileId: newProfileId, + metadata: MOCK_URI, + timestamp: block.timestamp + }); + } + + function testSetProfileMetadataURI_EmitsProperEvent() public { + expectProfileMetadataSetEvent(); + testSetProfileMetadataURI(); + } + + function testExecutorSetProfileMetadataURI_EmitsProperEvent() public { + expectProfileMetadataSetEvent(); + testExecutorSetProfileMetadataURI(); + } +} + +contract ProfileMetadataURITest_MetaTx is ProfileMetadataURITest, MetaTxNegatives { + mapping(address => uint256) cachedNonceByAddress; + + function setUp() public override(MetaTxNegatives, TestSetup) { + TestSetup.setUp(); + MetaTxNegatives.setUp(); + + cachedNonceByAddress[alienSigner] = _getSigNonce(alienSigner); + cachedNonceByAddress[otherSigner] = _getSigNonce(otherSigner); + cachedNonceByAddress[profileOwner] = _getSigNonce(profileOwner); + } + + function _setProfileMetadataURI( + uint256 pk, + uint256 profileId, + string memory metadataURI + ) internal virtual override { + address signer = vm.addr(pk); + uint256 nonce = cachedNonceByAddress[signer]; + uint256 deadline = type(uint256).max; + + bytes32 digest = _getSetProfileMetadataURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + hub.setProfileMetadataURIWithSig( + DataTypes.SetProfileMetadataURIWithSigData({ + delegatedSigner: signer == profileOwner ? address(0) : signer, + profileId: newProfileId, + metadataURI: MOCK_URI, + sig: _getSigStruct(pk, digest, deadline) + }) + ); + } + + function _executeMetaTx( + uint256 signerPk, + uint256 nonce, + uint256 deadline + ) internal virtual override { + bytes32 digest = _getSetProfileMetadataURITypedDataHash( + newProfileId, + MOCK_URI, + nonce, + deadline + ); + + hub.setProfileMetadataURIWithSig( + DataTypes.SetProfileMetadataURIWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + metadataURI: MOCK_URI, + sig: _getSigStruct(signerPk, digest, deadline) + }) + ); + } + + function _getDefaultMetaTxSignerPk() internal virtual override returns (uint256) { + return profileOwnerKey; + } +} diff --git a/test/foundry/ProfileNFTTest.t.sol b/test/foundry/ProfileNFTTest.t.sol new file mode 100644 index 0000000..a2a48a8 --- /dev/null +++ b/test/foundry/ProfileNFTTest.t.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './ERC721Test.t.sol'; + +contract ProfileNFTTest is BaseTest, ERC721Test { + function _mintERC721(address to) internal virtual override returns (uint256) { + return _createProfile(to); + } + + function _burnERC721(uint256 tokenId) internal virtual override { + return hub.burn(tokenId); + } + + function _getERC721TokenAddress() internal view virtual override returns (address) { + return address(hub); + } +} diff --git a/test/foundry/PublishingTest.t.sol b/test/foundry/PublishingTest.t.sol new file mode 100644 index 0000000..93ae9f0 --- /dev/null +++ b/test/foundry/PublishingTest.t.sol @@ -0,0 +1,500 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './helpers/SignatureHelpers.sol'; +import {PublishingHelpers} from './helpers/PublishingHelpers.sol'; + +abstract contract PublishingTest is BaseTest, SignatureHelpers, PublishingHelpers, SigSetup { + function replicateInitData() internal virtual { + // Default implementation does nothing. + } + + function _publish() internal virtual returns (uint256); + + function _publishWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 digestDeadline, + uint256 sigDeadline + ) internal virtual returns (uint256); + + function _publishWithSig(address delegatedSigner, uint256 signerPrivKey) + internal + virtual + returns (uint256) + { + return _publishWithSig(delegatedSigner, signerPrivKey, deadline, deadline); + } + + function _expectedPubFromInitData() + internal + view + virtual + returns (DataTypes.PublicationStruct memory); + + function setUp() public virtual override(SigSetup, TestSetup) { + TestSetup.setUp(); + SigSetup.setUp(); + } + + // negatives + function testCannotPublishIfNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _publish(); + } + + function testCannotPublishNotWhitelistedCollectModule() public virtual { + mockPostData.collectModule = address(0xC0FFEE); + replicateInitData(); + vm.prank(profileOwner); + vm.expectRevert(Errors.CollectModuleNotWhitelisted.selector); + _publish(); + } + + function testCannotPublishNotWhitelistedReferenceModule() public { + mockPostData.referenceModule = address(0xC0FFEE); + replicateInitData(); + vm.prank(profileOwner); + vm.expectRevert(Errors.ReferenceModuleNotWhitelisted.selector); + _publish(); + } + + function testCannotPublishWithSigNotWhitelistedCollectModule() public virtual { + mockPostData.collectModule = address(0xC0FFEE); + replicateInitData(); + vm.expectRevert(Errors.CollectModuleNotWhitelisted.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotPublishWithSigNotWhitelistedReferenceModule() public { + mockPostData.referenceModule = address(0xC0FFEE); + replicateInitData(); + vm.expectRevert(Errors.ReferenceModuleNotWhitelisted.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotPublishWithSigInvalidSigner() public { + vm.expectRevert(Errors.SignatureInvalid.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigInvalidNonce() public { + nonce = _getSigNonce(otherSigner) + 1; + vm.expectRevert(Errors.SignatureInvalid.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigInvalidDeadline() public { + vm.expectRevert(Errors.SignatureInvalid.selector); + _publishWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + digestDeadline: type(uint256).max, + sigDeadline: block.timestamp + 10 + }); + } + + function testCannotPublishIfNonceWasIncrementedWithAnotherAction() public { + assertEq(_getSigNonce(profileOwner), nonce, 'Wrong nonce before posting'); + + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + + uint256 pubId = _publishWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey + }); + assertEq(pubId, expectedPubId, 'Wrong pubId'); + + assertTrue(_getSigNonce(profileOwner) != nonce, 'Wrong nonce after posting'); + + vm.expectRevert(Errors.SignatureInvalid.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotPublishWithSigExpiredDeadline() public { + deadline = 10; + vm.warp(20); + + vm.expectRevert(Errors.SignatureExpired.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _publishWithSig({delegatedSigner: otherSigner, signerPrivKey: otherSignerKey}); + } + + // positives + function testPublish() public { + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + + vm.prank(profileOwner); + uint256 pubId = _publish(); + + assertEq(pubId, expectedPubId); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, pubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } + + function testPublishWithAWhitelistedReferenceModule() public { + mockPostData.referenceModule = address(mockReferenceModule); + mockPostData.referenceModuleInitData = abi.encode(1); + replicateInitData(); + + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + + vm.prank(profileOwner); + uint256 pubId = _publish(); + + assertEq(pubId, expectedPubId); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, pubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } + + function testPublishWithSig() public { + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + + uint256 pubId = _publishWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey + }); + assertEq(pubId, expectedPubId); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, pubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } + + function testExecutorPublish() public { + _setDelegatedExecutorApproval(profileOwner, otherSigner, true); + + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + + vm.prank(otherSigner); + uint256 pubId = _publish(); + assertEq(pubId, expectedPubId); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, pubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } + + function testExecutorPublishWithSig() public { + _setDelegatedExecutorApproval(profileOwner, otherSigner, true); + + uint256 expectedPubId = _getPubCount(newProfileId) + 1; + uint256 pubId = _publishWithSig({ + delegatedSigner: otherSigner, + signerPrivKey: otherSignerKey + }); + assertEq(pubId, expectedPubId); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, pubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } +} + +contract PostTest is PublishingTest { + function _publish() internal virtual override returns (uint256) { + return _post(mockPostData); + } + + function _publishWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 digestDeadline, + uint256 sigDeadline + ) internal virtual override returns (uint256) { + bytes32 digest = _getPostTypedDataHash(mockPostData, nonce, digestDeadline); + + return + _postWithSig( + _buildPostWithSigData( + delegatedSigner, + mockPostData, + _getSigStruct(signerPrivKey, digest, sigDeadline) + ) + ); + } + + function _expectedPubFromInitData() + internal + view + virtual + override + returns (DataTypes.PublicationStruct memory) + { + return _expectedPubFromInitData(mockPostData); + } +} + +contract CommentTest is PublishingTest { + uint256 postId; + + function replicateInitData() internal override { + mockCommentData.profileId = mockPostData.profileId; + mockCommentData.contentURI = mockPostData.contentURI; + mockCommentData.collectModule = mockPostData.collectModule; + mockCommentData.collectModuleInitData = mockPostData.collectModuleInitData; + mockCommentData.referenceModule = mockPostData.referenceModule; + mockCommentData.referenceModuleInitData = mockPostData.referenceModuleInitData; + } + + function _publish() internal override returns (uint256) { + return _comment(mockCommentData); + } + + function _publishWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 digestDeadline, + uint256 sigDeadline + ) internal override returns (uint256) { + bytes32 digest = _getCommentTypedDataHash(mockCommentData, nonce, digestDeadline); + + return + _commentWithSig( + _buildCommentWithSigData( + delegatedSigner, + mockCommentData, + _getSigStruct(signerPrivKey, digest, sigDeadline) + ) + ); + } + + function _expectedPubFromInitData() + internal + view + override + returns (DataTypes.PublicationStruct memory) + { + return _expectedPubFromInitData(mockCommentData); + } + + function setUp() public override { + PublishingTest.setUp(); + + vm.prank(profileOwner); + postId = _post(mockPostData); + } + + // negatives + function testCannotCommentOnNonExistentPublication() public { + uint256 nonExistentPubId = _getPubCount(newProfileId) + 10; + + replicateInitData(); + mockCommentData.pubIdPointed = nonExistentPubId; + + vm.prank(profileOwner); + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _publish(); + } + + function testCannotCommentWithSigOnNonExistentPublication() public { + uint256 nonExistentPubId = _getPubCount(newProfileId) + 10; + + replicateInitData(); + mockCommentData.pubIdPointed = nonExistentPubId; + + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotCommentOnTheSamePublicationBeingCreated() public { + uint256 nextPubId = _getPubCount(newProfileId) + 1; + + replicateInitData(); + mockCommentData.pubIdPointed = nextPubId; + + vm.prank(profileOwner); + vm.expectRevert(Errors.CannotCommentOnSelf.selector); + _publish(); + } + + function testCannotCommentWithSigOnTheSamePublicationBeingCreated() public { + uint256 nextPubId = _getPubCount(newProfileId) + 1; + + replicateInitData(); + mockCommentData.pubIdPointed = nextPubId; + + vm.expectRevert(Errors.CannotCommentOnSelf.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotCommentIfBlocked() public { + uint256 commenterProfileId = _createProfile(profileOwner); + mockCommentData.profileId = commenterProfileId; + vm.prank(profileOwner); + hub.setBlockStatus( + mockPostData.profileId, + _toUint256Array(commenterProfileId), + _toBoolArray(true) + ); + vm.expectRevert(Errors.Blocked.selector); + vm.prank(profileOwner); + _publish(); + } + + function testCannotCommentWithSigIfBlocked() public { + uint256 commenterProfileId = _createProfile(profileOwner); + mockCommentData.profileId = commenterProfileId; + vm.prank(profileOwner); + hub.setBlockStatus( + mockPostData.profileId, + _toUint256Array(commenterProfileId), + _toBoolArray(true) + ); + vm.expectRevert(Errors.Blocked.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + // scenarios + function testPostWithReferenceModuleAndComment() public { + mockPostData.referenceModule = address(mockReferenceModule); + mockPostData.referenceModuleInitData = abi.encode(1); + vm.prank(profileOwner); + postId = _post(mockPostData); + + mockCommentData.pubIdPointed = postId; + vm.prank(profileOwner); + uint256 commentPubId = _publish(); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, commentPubId); + _verifyPublication(pub, _expectedPubFromInitData()); + } +} + +contract MirrorTest is PublishingTest { + uint256 postId; + + function replicateInitData() internal override { + mockMirrorData.profileId = mockPostData.profileId; + mockMirrorData.referenceModule = mockPostData.referenceModule; + mockMirrorData.referenceModuleInitData = mockPostData.referenceModuleInitData; + } + + function _publish() internal override returns (uint256) { + return _mirror(mockMirrorData); + } + + function _publishWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 digestDeadline, + uint256 sigDeadline + ) internal override returns (uint256) { + bytes32 digest = _getMirrorTypedDataHash(mockMirrorData, nonce, digestDeadline); + + return + _mirrorWithSig( + _buildMirrorWithSigData( + delegatedSigner, + mockMirrorData, + _getSigStruct(signerPrivKey, digest, sigDeadline) + ) + ); + } + + function _expectedPubFromInitData() + internal + view + override + returns (DataTypes.PublicationStruct memory) + { + return _expectedPubFromInitData(mockMirrorData); + } + + function setUp() public override { + PublishingTest.setUp(); + + vm.prank(profileOwner); + postId = _post(mockPostData); + } + + // ignored - these tests don't apply to mirrors + function testCannotPublishNotWhitelistedCollectModule() public override {} + + function testCannotPublishWithSigNotWhitelistedCollectModule() public override {} + + // negatives + + function testCannotMirrorNonExistentPublication() public { + uint256 nonExistentPubId = _getPubCount(newProfileId) + 10; + + replicateInitData(); + mockMirrorData.pubIdPointed = nonExistentPubId; + + vm.prank(profileOwner); + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _publish(); + } + + function testCannotMirrorWithSigNonExistentPublication() public { + uint256 nonExistentPubId = _getPubCount(newProfileId) + 10; + + replicateInitData(); + mockMirrorData.pubIdPointed = nonExistentPubId; + + vm.expectRevert(Errors.PublicationDoesNotExist.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotMirrorIfBlocked() public { + uint256 mirrorerProfileId = _createProfile(profileOwner); + mockMirrorData.profileId = mirrorerProfileId; + vm.prank(profileOwner); + hub.setBlockStatus( + mockPostData.profileId, + _toUint256Array(mirrorerProfileId), + _toBoolArray(true) + ); + vm.expectRevert(Errors.Blocked.selector); + vm.prank(profileOwner); + _publish(); + } + + function testCannotMirrorWithSigIfBlocked() public { + uint256 mirrorerProfileId = _createProfile(profileOwner); + mockMirrorData.profileId = mirrorerProfileId; + vm.prank(profileOwner); + hub.setBlockStatus( + mockPostData.profileId, + _toUint256Array(mirrorerProfileId), + _toBoolArray(true) + ); + vm.expectRevert(Errors.Blocked.selector); + _publishWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + // scenarios + function testMirrorAnotherMirrorShouldPointToOriginalPost() public { + mockMirrorData.pubIdPointed = postId; + vm.prank(profileOwner); + uint256 firstMirrorId = _publish(); + + mockMirrorData.pubIdPointed = firstMirrorId; + vm.prank(profileOwner); + uint256 secondMirrorId = _publish(); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, secondMirrorId); + mockMirrorData.pubIdPointed = postId; // We're expecting a mirror to point at the original post ID + _verifyPublication(pub, _expectedPubFromInitData(mockMirrorData)); + } + + function testMirrorAnotherMirrorWithSigShouldPointToOriginalPost() public { + mockMirrorData.pubIdPointed = postId; + vm.prank(profileOwner); + uint256 firstMirrorId = _publish(); + + mockMirrorData.pubIdPointed = firstMirrorId; + uint256 secondMirrorId = _publishWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey + }); + + DataTypes.PublicationStruct memory pub = _getPub(newProfileId, secondMirrorId); + mockMirrorData.pubIdPointed = postId; // We're expecting a mirror to point at the original post ID + _verifyPublication(pub, _expectedPubFromInitData(mockMirrorData)); + } +} diff --git a/test/foundry/SetBlockStatusTest.t.sol b/test/foundry/SetBlockStatusTest.t.sol new file mode 100644 index 0000000..b4040c8 --- /dev/null +++ b/test/foundry/SetBlockStatusTest.t.sol @@ -0,0 +1,415 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './MetaTxNegatives.t.sol'; + +contract SetBlockStatusTest is BaseTest { + address constant PROFILE_OWNER = address(0); + + uint256 constant statusSetterProfileOwnerPk = 0x7357; + address statusSetterProfileOwner; + uint256 statusSetterProfileId; + + uint256 constant blockeeProfileOwnerPk = 0xF01108; + address blockeeProfileOwner; + uint256 blockeeProfileId; + + uint256 constant anotherBlockeeProfileOwnerPk = 0xF01109; + address anotherBlockeeProfileOwner; + uint256 anotherBlockeeProfileId; + + address followNFTAddress; + + function setUp() public virtual override { + super.setUp(); + + statusSetterProfileOwner = vm.addr(statusSetterProfileOwnerPk); + statusSetterProfileId = _createProfile(statusSetterProfileOwner); + + blockeeProfileOwner = vm.addr(blockeeProfileOwnerPk); + blockeeProfileId = _createProfile(blockeeProfileOwner); + + anotherBlockeeProfileOwner = vm.addr(anotherBlockeeProfileOwnerPk); + anotherBlockeeProfileId = _createProfile(anotherBlockeeProfileOwner); + + _follow(blockeeProfileOwner, blockeeProfileId, statusSetterProfileId, 0, ''); + + followNFTAddress = hub.getFollowNFT(statusSetterProfileId); + followNFT = FollowNFT(followNFTAddress); + } + + ////////////////////////////////////////////////////////// + // Set block status - Negatives + ////////////////////////////////////////////////////////// + function testCannotSetBlockStatusIfPaused() public { + vm.prank(governance); + hub.setState(DataTypes.ProtocolState.Paused); + + vm.expectRevert(Errors.Paused.selector); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + } + + function testCannotSetBlockStatusIfSetterProfileDoesNotExist() public virtual { + vm.prank(statusSetterProfileOwner); + hub.burn(statusSetterProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + } + + function testCannotSetBlockStatusIfNotOwnerOrApprovedDelegatedExecutorOfSetterProfile( + uint256 nonOwnerNorDelegatedExecutorPk + ) public virtual { + nonOwnerNorDelegatedExecutorPk = bound( + nonOwnerNorDelegatedExecutorPk, + 1, + ISSECP256K1_CURVE_ORDER - 1 + ); + address nonOwnerNorDelegatedExecutor = vm.addr(nonOwnerNorDelegatedExecutorPk); + vm.assume(nonOwnerNorDelegatedExecutor != address(0)); + vm.assume(nonOwnerNorDelegatedExecutor != statusSetterProfileOwner); + vm.assume( + !hub.isDelegatedExecutorApproved(statusSetterProfileOwner, nonOwnerNorDelegatedExecutor) + ); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _setBlockStatus({ + pk: nonOwnerNorDelegatedExecutorPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _setBlockStatus({ + pk: nonOwnerNorDelegatedExecutorPk, + isStatusSetterProfileOwner: false, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + } + + function testCannotSetBlockStatusIfProfilesAndStatusArrayLengthMismatches() public virtual { + vm.expectRevert(Errors.ArrayMismatch.selector); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array( + blockeeProfileId, + anotherBlockeeProfileId + ), + blockStatus: _toBoolArray(true) + }); + } + + function testCannotSetBlockStatusIfBlockeeProfileDoesNotExist() public virtual { + vm.prank(blockeeProfileOwner); + hub.burn(blockeeProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + } + + function testCannotBlockItself() public virtual { + vm.expectRevert(Errors.SelfBlock.selector); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(statusSetterProfileId), + blockStatus: _toBoolArray(true) + }); + } + + ////////////////////////////////////////////////////////// + // Set block status - Scenarios + ////////////////////////////////////////////////////////// + function testSetBlockStatusEmitExpectedEventsAndSetExpectedStatus() public { + assertFalse(hub.isBlocked(blockeeProfileId, statusSetterProfileId)); + assertFalse(hub.isBlocked(anotherBlockeeProfileId, statusSetterProfileId)); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Blocked(statusSetterProfileId, blockeeProfileId, block.timestamp); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Blocked(statusSetterProfileId, anotherBlockeeProfileId, block.timestamp); + + vm.expectCall(followNFTAddress, abi.encodeCall(followNFT.processBlock, (blockeeProfileId))); + vm.expectCall( + followNFTAddress, + abi.encodeCall(followNFT.processBlock, (anotherBlockeeProfileId)) + ); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array( + blockeeProfileId, + anotherBlockeeProfileId + ), + blockStatus: _toBoolArray(true, true) + }); + + assertTrue(hub.isBlocked(blockeeProfileId, statusSetterProfileId)); + assertTrue(hub.isBlocked(anotherBlockeeProfileId, statusSetterProfileId)); + + _refreshCachedNonces(); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Blocked(statusSetterProfileId, blockeeProfileId, block.timestamp); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Unblocked(statusSetterProfileId, anotherBlockeeProfileId, block.timestamp); + + vm.expectCall(followNFTAddress, abi.encodeCall(followNFT.processBlock, (blockeeProfileId))); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array( + blockeeProfileId, + anotherBlockeeProfileId + ), + blockStatus: _toBoolArray(true, false) + }); + + assertTrue(hub.isBlocked(blockeeProfileId, statusSetterProfileId)); + assertFalse(hub.isBlocked(anotherBlockeeProfileId, statusSetterProfileId)); + } + + function testSetBlockStatusAsBlockedForFollowerMakesHimUnfollowFirst() public { + assertTrue(hub.isFollowing(blockeeProfileId, statusSetterProfileId)); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Unfollowed(blockeeProfileId, statusSetterProfileId, block.timestamp); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Blocked(statusSetterProfileId, blockeeProfileId, block.timestamp); + + vm.expectCall(followNFTAddress, abi.encodeCall(followNFT.processBlock, (blockeeProfileId))); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + + assertTrue(hub.isBlocked(blockeeProfileId, statusSetterProfileId)); + assertFalse(hub.isFollowing(blockeeProfileId, statusSetterProfileId)); + } + + function testSetBlockStatusAsBlockedDoesNotCallFollowNFTIfNotDeployed() public { + // Creates a fresh profile so it doesn't have a Follow NFT collection deployed yet. + statusSetterProfileId = _createProfile(statusSetterProfileOwner); + + // As the Follow NFT has not been deployed yet, the address is zero, so if a `followNFT.processBlock(...)` call + // is performed to it, this test must revert. + assertEq(hub.getFollowNFT(statusSetterProfileId), address(0)); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Blocked(statusSetterProfileId, blockeeProfileId, block.timestamp); + + _setBlockStatus({ + pk: statusSetterProfileOwnerPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + + assertTrue(hub.isBlocked(blockeeProfileId, statusSetterProfileId)); + } + + function _refreshCachedNonces() internal virtual { + // Nothing to do there. + } + + function _setBlockStatus( + uint256 pk, + bool isStatusSetterProfileOwner, + uint256 byProfileId, + uint256[] memory idsOfProfilesToSetBlockStatus, + bool[] memory blockStatus + ) internal virtual { + vm.prank(vm.addr(pk)); + hub.setBlockStatus(byProfileId, idsOfProfilesToSetBlockStatus, blockStatus); + } +} + +contract SetBlockStatusMetaTxTest is SetBlockStatusTest, MetaTxNegatives { + mapping(address => uint256) cachedNonceByAddress; + + function setUp() public override(SetBlockStatusTest, MetaTxNegatives) { + SetBlockStatusTest.setUp(); + MetaTxNegatives.setUp(); + + cachedNonceByAddress[statusSetterProfileOwner] = _getSigNonce(statusSetterProfileOwner); + } + + function _refreshCachedNonces() internal override { + cachedNonceByAddress[statusSetterProfileOwner] = _getSigNonce(statusSetterProfileOwner); + } + + function _setBlockStatus( + uint256 pk, + bool isStatusSetterProfileOwner, + uint256 byProfileId, + uint256[] memory idsOfProfilesToSetBlockStatus, + bool[] memory blockStatus + ) internal override { + address signer = vm.addr(pk); + hub.setBlockStatusWithSig( + _getSignedData({ + signerPk: pk, + delegatedSigner: isStatusSetterProfileOwner ? PROFILE_OWNER : signer, + byProfileId: byProfileId, + idsOfProfilesToSetBlockStatus: idsOfProfilesToSetBlockStatus, + blockStatus: blockStatus, + nonce: cachedNonceByAddress[signer], + deadline: type(uint256).max + }) + ); + } + + function _executeMetaTx( + uint256 signerPk, + uint256 nonce, + uint256 deadline + ) internal override { + hub.setBlockStatusWithSig( + _getSignedData({ + signerPk: signerPk, + delegatedSigner: PROFILE_OWNER, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true), + nonce: nonce, + deadline: deadline + }) + ); + } + + function _getDefaultMetaTxSignerPk() internal override returns (uint256) { + return blockeeProfileOwnerPk; + } + + function _calculateSetBlockStatusWithSigDigest( + uint256 byProfileId, + uint256[] memory idsOfProfilesToSetBlockStatus, + bool[] memory blockStatus, + uint256 nonce, + uint256 deadline + ) internal returns (bytes32) { + return + _calculateDigest( + keccak256( + abi.encode( + SET_BLOCK_STATUS_WITH_SIG_TYPEHASH, + byProfileId, + keccak256(abi.encodePacked(idsOfProfilesToSetBlockStatus)), + keccak256(abi.encodePacked(blockStatus)), + nonce, + deadline + ) + ) + ); + } + + function _getSignedData( + uint256 signerPk, + address delegatedSigner, + uint256 byProfileId, + uint256[] memory idsOfProfilesToSetBlockStatus, + bool[] memory blockStatus, + uint256 nonce, + uint256 deadline + ) internal returns (DataTypes.SetBlockStatusWithSigData memory) { + return + DataTypes.SetBlockStatusWithSigData({ + delegatedSigner: delegatedSigner, + byProfileId: byProfileId, + idsOfProfilesToSetBlockStatus: idsOfProfilesToSetBlockStatus, + blockStatus: blockStatus, + sig: _getSigStruct({ + pKey: signerPk, + digest: _calculateSetBlockStatusWithSigDigest( + byProfileId, + idsOfProfilesToSetBlockStatus, + blockStatus, + nonce, + deadline + ), + deadline: deadline + }) + }); + } + + function testCannotSetBlockStatusIfNotOwnerOrApprovedDelegatedExecutorOfSetterProfile( + uint256 nonOwnerNorDelegatedExecutorPk + ) public override { + nonOwnerNorDelegatedExecutorPk = bound( + nonOwnerNorDelegatedExecutorPk, + 1, + ISSECP256K1_CURVE_ORDER - 1 + ); + address nonOwnerNorDelegatedExecutor = vm.addr(nonOwnerNorDelegatedExecutorPk); + vm.assume(nonOwnerNorDelegatedExecutor != address(0)); + vm.assume(nonOwnerNorDelegatedExecutor != statusSetterProfileOwner); + vm.assume( + !hub.isDelegatedExecutorApproved(statusSetterProfileOwner, nonOwnerNorDelegatedExecutor) + ); + + vm.expectRevert(Errors.SignatureInvalid.selector); + + _setBlockStatus({ + pk: nonOwnerNorDelegatedExecutorPk, + isStatusSetterProfileOwner: true, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _setBlockStatus({ + pk: nonOwnerNorDelegatedExecutorPk, + isStatusSetterProfileOwner: false, + byProfileId: statusSetterProfileId, + idsOfProfilesToSetBlockStatus: _toUint256Array(blockeeProfileId), + blockStatus: _toBoolArray(true) + }); + } +} diff --git a/test/foundry/SetFollowModule.t.sol b/test/foundry/SetFollowModule.t.sol new file mode 100644 index 0000000..73ee85f --- /dev/null +++ b/test/foundry/SetFollowModule.t.sol @@ -0,0 +1,182 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import '../../contracts/mocks/MockFollowModule.sol'; +import './helpers/SignatureHelpers.sol'; + +// TODO: Refactor out all `hub.` calls (if we decide to go this route) +contract SetFollowModuleTest is BaseTest, SignatureHelpers, SigSetup { + address mockFollowModule; + + function setUp() public virtual override(SigSetup, TestSetup) { + TestSetup.setUp(); + SigSetup.setUp(); + mockFollowModule = address(new MockFollowModule()); + vm.prank(governance); + hub.whitelistFollowModule(mockFollowModule, true); + } + + function _setFollowModulehWithSig(address delegatedSigner, uint256 signerPrivKey) + internal + virtual + { + _setFollowModulehWithSig(delegatedSigner, signerPrivKey, deadline, deadline); + } + + function _setFollowModulehWithSig( + address delegatedSigner, + uint256 signerPrivKey, + uint256 digestDeadline, + uint256 sigDeadline + ) internal virtual { + bytes32 digest = _getSetFollowModuleTypedDataHash( + newProfileId, + mockFollowModule, + abi.encode(1), + nonce, + digestDeadline + ); + + hub.setFollowModuleWithSig( + DataTypes.SetFollowModuleWithSigData({ + delegatedSigner: delegatedSigner, + profileId: newProfileId, + followModule: mockFollowModule, + followModuleInitData: abi.encode(1), + sig: _getSigStruct(signerPrivKey, digest, sigDeadline) + }) + ); + } + + // Negatives + function testCannotSetFollowModuleNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + hub.setFollowModule(newProfileId, address(0), ''); + } + + function testCannotSetFollowModuleNotWhitelisted() public { + vm.expectRevert(Errors.FollowModuleNotWhitelisted.selector); + vm.prank(profileOwner); + hub.setFollowModule(newProfileId, address(1), ''); + } + + function testCannotSetFollowModuleWithWrongInitData() public { + vm.expectRevert(bytes('')); + vm.prank(profileOwner); + hub.setFollowModule(newProfileId, mockFollowModule, ''); + } + + // Positives + function testSetFollowModule() public { + vm.prank(profileOwner); + hub.setFollowModule(newProfileId, mockFollowModule, abi.encode(1)); + assertEq(hub.getFollowModule(newProfileId), mockFollowModule); + + vm.prank(profileOwner); + hub.setFollowModule(newProfileId, address(0), ''); + assertEq(hub.getFollowModule(newProfileId), address(0)); + } + + function testExecutorSetFollowModule() public { + assertEq(hub.getFollowModule(newProfileId), address(0)); + vm.prank(profileOwner); + hub.setDelegatedExecutorApproval(otherSigner, true); + + address mockFollowModule = address(new MockFollowModule()); + vm.prank(governance); + hub.whitelistFollowModule(mockFollowModule, true); + + vm.prank(otherSigner); + hub.setFollowModule(newProfileId, mockFollowModule, abi.encode(1)); + assertEq(hub.getFollowModule(newProfileId), mockFollowModule); + } + + // Meta-tx + // Negatives + function testCannotSetFollowModuleNotWhitelistedWithSig() public { + vm.expectRevert(Errors.FollowModuleNotWhitelisted.selector); + bytes32 digest = _getSetFollowModuleTypedDataHash( + newProfileId, + address(1), + '', + nonce, + deadline + ); + + hub.setFollowModuleWithSig( + DataTypes.SetFollowModuleWithSigData({ + delegatedSigner: address(0), + profileId: newProfileId, + followModule: address(1), + followModuleInitData: '', + sig: _getSigStruct(profileOwnerKey, digest, deadline) + }) + ); + } + + function testCannotPublishWithSigInvalidSigner() public { + vm.expectRevert(Errors.SignatureInvalid.selector); + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigInvalidNonce() public { + nonce = _getSigNonce(otherSigner) + 1; + vm.expectRevert(Errors.SignatureInvalid.selector); + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigInvalidDeadline() public { + vm.expectRevert(Errors.SignatureInvalid.selector); + _setFollowModulehWithSig({ + delegatedSigner: address(0), + signerPrivKey: profileOwnerKey, + digestDeadline: type(uint256).max, + sigDeadline: block.timestamp + 10 + }); + } + + function testCannotPublishIfNonceWasIncrementedWithAnotherAction() public { + assertEq(_getSigNonce(profileOwner), nonce, 'Wrong nonce before posting'); + + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + + assertTrue(_getSigNonce(profileOwner) != nonce, 'Wrong nonce after posting'); + + vm.expectRevert(Errors.SignatureInvalid.selector); + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + } + + function testCannotPublishWithSigExpiredDeadline() public { + deadline = 10; + vm.warp(20); + + vm.expectRevert(Errors.SignatureExpired.selector); + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: otherSignerKey}); + } + + function testCannotPublishWithSigNotExecutor() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _setFollowModulehWithSig({delegatedSigner: otherSigner, signerPrivKey: otherSignerKey}); + } + + function testSetFollowModuleWithSigNotExecutorFails() public { + vm.expectRevert(Errors.ExecutorInvalid.selector); + _setFollowModulehWithSig({delegatedSigner: otherSigner, signerPrivKey: otherSignerKey}); + } + + // Postivies + function testPublishWithSig() public { + assertEq(hub.getFollowModule(newProfileId), address(0)); + _setFollowModulehWithSig({delegatedSigner: address(0), signerPrivKey: profileOwnerKey}); + assertEq(hub.getFollowModule(newProfileId), mockFollowModule); + } + + function testExecutorPublishWithSig() public { + _setDelegatedExecutorApproval(profileOwner, otherSigner, true); + + assertEq(hub.getFollowModule(newProfileId), address(0)); + _setFollowModulehWithSig({delegatedSigner: otherSigner, signerPrivKey: otherSignerKey}); + assertEq(hub.getFollowModule(newProfileId), mockFollowModule); + } +} diff --git a/test/foundry/UnfollowTest.t.sol b/test/foundry/UnfollowTest.t.sol new file mode 100644 index 0000000..0281605 --- /dev/null +++ b/test/foundry/UnfollowTest.t.sol @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './base/BaseTest.t.sol'; +import './MetaTxNegatives.t.sol'; +import {Strings} from '@openzeppelin/contracts/utils/Strings.sol'; +import {IFollowNFT} from 'contracts/interfaces/IFollowNFT.sol'; + +contract UnfollowTest is BaseTest { + uint256 constant MINT_NEW_TOKEN = 0; + address constant PROFILE_OWNER = address(0); + address targetProfileOwner = address(0xC0FFEE); + uint256 targetProfileId; + uint256 constant nonFollowingProfileOwnerPk = 0x7357; + address nonFollowingProfileOwner; + uint256 nonFollowingProfileId; + uint256 constant unfollowerProfileOwnerPk = 0xF01108; + address unfollowerProfileOwner; + uint256 unfollowerProfileId; + address targetFollowNFT; + uint256 followTokenId; + + function setUp() public virtual override { + super.setUp(); + + targetProfileId = _createProfile(targetProfileOwner); + nonFollowingProfileOwner = vm.addr(nonFollowingProfileOwnerPk); + nonFollowingProfileId = _createProfile(nonFollowingProfileOwner); + unfollowerProfileOwnerPk; + unfollowerProfileOwner = vm.addr(unfollowerProfileOwnerPk); + unfollowerProfileId = _createProfile(unfollowerProfileOwner); + followTokenId = _follow( + unfollowerProfileOwner, + unfollowerProfileId, + targetProfileId, + 0, + '' + )[0]; + + targetFollowNFT = hub.getFollowNFT(targetProfileId); + followNFT = FollowNFT(targetFollowNFT); + } + + ////////////////////////////////////////////////////////// + // Unfollow - Negatives + ////////////////////////////////////////////////////////// + + function testCannotUnfollowIfPaused() public { + vm.prank(governance); + hub.setState(DataTypes.ProtocolState.Paused); + + vm.expectRevert(Errors.Paused.selector); + + _unfollow({ + pk: unfollowerProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + } + + function testCannotUnfollowIfUnfollowerProfileDoesNotExist() public { + vm.prank(unfollowerProfileOwner); + hub.burn(unfollowerProfileId); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _unfollow({ + pk: unfollowerProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + } + + function testCannotUnfollowIfSomeOfTheProfilesToUnfollowDoNotExist(uint256 unexistentProfileId) + public + { + vm.assume(!hub.exists(unexistentProfileId)); + + assertTrue(hub.isFollowing(unfollowerProfileId, targetProfileId)); + + vm.expectRevert(Errors.TokenDoesNotExist.selector); + + _unfollow({ + pk: unfollowerProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId, unexistentProfileId) + }); + + // Asserts that the unfollow operation has been completely reverted after one of the unfollow's failed. + assertTrue(hub.isFollowing(unfollowerProfileId, targetProfileId)); + } + + function testCannotUnfollowIfTheProfileHasNeverBeenFollowedBefore() public { + uint256 hasNeverBeenFollowedProfileId = _createProfile(targetProfileOwner); + + vm.expectRevert(Errors.NotFollowing.selector); + + _unfollow({ + pk: unfollowerProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(hasNeverBeenFollowedProfileId) + }); + } + + function testCannotUnfollowIfNotFollowingTheTargetProfile() public { + vm.expectRevert(Errors.NotFollowing.selector); + + _unfollow({ + pk: nonFollowingProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: nonFollowingProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + } + + function testCannotUnfollowIfNotProfileOwnerOrDelegatedExecutor(uint256 executorPk) public { + executorPk = bound( + executorPk, + 1, + 115792089237316195423570985008687907852837564279074904382605163141518161494337 - 1 + ); + address executor = vm.addr(executorPk); + vm.assume(executor != unfollowerProfileOwner); + vm.assume(!hub.isDelegatedExecutorApproved(unfollowerProfileOwner, executor)); + vm.assume(!followNFT.isApprovedForAll(unfollowerProfileOwner, executor)); + + uint256 followTokenId = followNFT.getFollowTokenId(unfollowerProfileId); + vm.prank(unfollowerProfileOwner); + followNFT.wrap(followTokenId); + + vm.expectRevert(Errors.ExecutorInvalid.selector); + + _unfollow({ + pk: executorPk, + isUnfollowerProfileOwner: false, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + } + + ////////////////////////////////////////////////////////// + // Unfollow - Scenarios + ////////////////////////////////////////////////////////// + + function testUnfollowAsUnfollowerOwner() public { + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Unfollowed(unfollowerProfileId, targetProfileId, block.timestamp); + + vm.expectCall( + targetFollowNFT, + abi.encodeCall(followNFT.unfollow, (unfollowerProfileId, unfollowerProfileOwner)) + ); + + _unfollow({ + pk: unfollowerProfileOwnerPk, + isUnfollowerProfileOwner: true, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + + assertFalse(hub.isFollowing(unfollowerProfileId, targetProfileId)); + } + + function testUnfollowAsUnfollowerApprovedDelegatedExecutor(uint256 approvedDelegatedExecutorPk) + public + { + approvedDelegatedExecutorPk = bound( + approvedDelegatedExecutorPk, + 1, + ISSECP256K1_CURVE_ORDER - 1 + ); + address approvedDelegatedExecutor = vm.addr(approvedDelegatedExecutorPk); + vm.assume(approvedDelegatedExecutor != address(0)); + vm.assume(approvedDelegatedExecutor != unfollowerProfileOwner); + + vm.prank(unfollowerProfileOwner); + hub.setDelegatedExecutorApproval(approvedDelegatedExecutor, true); + + vm.expectEmit(true, false, false, true, address(hub)); + emit Events.Unfollowed(unfollowerProfileId, targetProfileId, block.timestamp); + + vm.expectCall( + targetFollowNFT, + abi.encodeCall(followNFT.unfollow, (unfollowerProfileId, approvedDelegatedExecutor)) + ); + + _unfollow({ + pk: approvedDelegatedExecutorPk, + isUnfollowerProfileOwner: false, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId) + }); + + assertFalse(hub.isFollowing(unfollowerProfileId, targetProfileId)); + } + + function _unfollow( + uint256 pk, + bool isUnfollowerProfileOwner, + uint256 unfollowerProfileId, + uint256[] memory idsOfProfilesToUnfollow + ) internal virtual { + vm.prank(vm.addr(pk)); + hub.unfollow(unfollowerProfileId, idsOfProfilesToUnfollow); + } +} + +contract UnfollowMetaTxTest is UnfollowTest, MetaTxNegatives { + mapping(address => uint256) cachedNonceByAddress; + + function setUp() public override(UnfollowTest, MetaTxNegatives) { + UnfollowTest.setUp(); + MetaTxNegatives.setUp(); + + cachedNonceByAddress[nonFollowingProfileOwner] = _getSigNonce(nonFollowingProfileOwner); + cachedNonceByAddress[unfollowerProfileOwner] = _getSigNonce(unfollowerProfileOwner); + } + + function _unfollow( + uint256 pk, + bool isUnfollowerProfileOwner, + uint256 unfollowerProfileId, + uint256[] memory idsOfProfilesToUnfollow + ) internal virtual override { + address signer = vm.addr(pk); + uint256 nonce = cachedNonceByAddress[signer]; + hub.unfollowWithSig( + _getSignedData({ + signerPk: pk, + delegatedSigner: isUnfollowerProfileOwner ? PROFILE_OWNER : signer, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: idsOfProfilesToUnfollow, + nonce: nonce, + deadline: type(uint256).max + }) + ); + } + + function _executeMetaTx( + uint256 signerPk, + uint256 nonce, + uint256 deadline + ) internal virtual override { + hub.unfollowWithSig( + _getSignedData({ + signerPk: signerPk, + delegatedSigner: PROFILE_OWNER, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: _toUint256Array(targetProfileId), + nonce: nonce, + deadline: deadline + }) + ); + } + + function _getDefaultMetaTxSignerPk() internal virtual override returns (uint256) { + return unfollowerProfileOwnerPk; + } + + function _calculateUnfollowWithSigDigest( + uint256 unfollowerProfileId, + uint256[] memory idsOfProfilesToUnfollow, + uint256 nonce, + uint256 deadline + ) internal returns (bytes32) { + return + _calculateDigest( + keccak256( + abi.encode( + UNFOLLOW_WITH_SIG_TYPEHASH, + unfollowerProfileId, + keccak256(abi.encodePacked(idsOfProfilesToUnfollow)), + nonce, + deadline + ) + ) + ); + } + + function _getSignedData( + uint256 signerPk, + address delegatedSigner, + uint256 unfollowerProfileId, + uint256[] memory idsOfProfilesToUnfollow, + uint256 nonce, + uint256 deadline + ) internal returns (DataTypes.UnfollowWithSigData memory) { + return + DataTypes.UnfollowWithSigData({ + delegatedSigner: delegatedSigner, + unfollowerProfileId: unfollowerProfileId, + idsOfProfilesToUnfollow: idsOfProfilesToUnfollow, + sig: _getSigStruct({ + pKey: signerPk, + digest: _calculateUnfollowWithSigDigest( + unfollowerProfileId, + idsOfProfilesToUnfollow, + nonce, + deadline + ), + deadline: deadline + }) + }); + } +} diff --git a/test/foundry/base/BaseTest.t.sol b/test/foundry/base/BaseTest.t.sol new file mode 100644 index 0000000..b2cce72 --- /dev/null +++ b/test/foundry/base/BaseTest.t.sol @@ -0,0 +1,590 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './TestSetup.t.sol'; +import '../../../contracts/libraries/DataTypes.sol'; + +contract BaseTest is TestSetup { + function _getSetDefaultProfileTypedDataHash( + address wallet, + uint256 profileId, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode(SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH, wallet, profileId, nonce, deadline) + ); + return _calculateDigest(structHash); + } + + function _getSetProfileMetadataURITypedDataHash( + uint256 profileId, + string memory metadataURI, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + SET_PROFILE_METADATA_URI_WITH_SIG_TYPEHASH, + profileId, + keccak256(bytes(metadataURI)), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getSetFollowModuleTypedDataHash( + uint256 profileId, + address followModule, + bytes memory followModuleInitData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + SET_FOLLOW_MODULE_WITH_SIG_TYPEHASH, + profileId, + followModule, + keccak256(followModuleInitData), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getSetDelegatedExecutorApprovalTypedDataHash( + address onBehalfOf, + address executor, + bool approved, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + SET_DELEGATED_EXECUTOR_APPROVAL_WITH_SIG_TYPEHASH, + onBehalfOf, + executor, + approved, + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getSetProfileImageURITypedDataHash( + uint256 profileId, + string memory imageURI, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + SET_PROFILE_IMAGE_URI_WITH_SIG_TYPEHASH, + profileId, + keccak256(bytes(imageURI)), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getSetFollowNFTURITypedDataHash( + uint256 profileId, + string memory followNFTURI, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + SET_FOLLOW_NFT_URI_WITH_SIG_TYPEHASH, + profileId, + keccak256(bytes(followNFTURI)), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getBurnTypedDataHash( + uint256 profileId, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode(BURN_WITH_SIG_TYPEHASH, profileId, nonce, deadline) + ); + return _calculateDigest(structHash); + } + + function _getPostTypedDataHash( + uint256 profileId, + string memory contentURI, + address collectModule, + bytes memory collectModuleInitData, + address referenceModule, + bytes memory referenceModuleInitData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + POST_WITH_SIG_TYPEHASH, + profileId, + keccak256(bytes(contentURI)), + collectModule, + keccak256(collectModuleInitData), + referenceModule, + keccak256(referenceModuleInitData), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getPostTypedDataHash( + DataTypes.PostData memory postData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + return + _getPostTypedDataHash({ + profileId: postData.profileId, + contentURI: postData.contentURI, + collectModule: postData.collectModule, + collectModuleInitData: postData.collectModuleInitData, + referenceModule: postData.referenceModule, + referenceModuleInitData: postData.referenceModuleInitData, + nonce: nonce, + deadline: deadline + }); + } + + function _getCommentTypedDataHash( + uint256 profileId, + string memory contentURI, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes memory referenceModuleData, + address collectModule, + bytes memory collectModuleInitData, + address referenceModule, + bytes memory referenceModuleInitData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + COMMENT_WITH_SIG_TYPEHASH, + profileId, + keccak256(bytes(contentURI)), + profileIdPointed, + pubIdPointed, + keccak256(referenceModuleData), + collectModule, + keccak256(collectModuleInitData), + referenceModule, + keccak256(referenceModuleInitData), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getCommentTypedDataHash( + DataTypes.CommentData memory commentData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + return + _getCommentTypedDataHash({ + profileId: commentData.profileId, + contentURI: commentData.contentURI, + profileIdPointed: commentData.profileIdPointed, + pubIdPointed: commentData.pubIdPointed, + referenceModuleData: commentData.referenceModuleData, + collectModule: commentData.collectModule, + collectModuleInitData: commentData.collectModuleInitData, + referenceModule: commentData.referenceModule, + referenceModuleInitData: commentData.referenceModuleInitData, + nonce: nonce, + deadline: deadline + }); + } + + function _getMirrorTypedDataHash( + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes memory referenceModuleData, + address referenceModule, + bytes memory referenceModuleInitData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + MIRROR_WITH_SIG_TYPEHASH, + profileId, + profileIdPointed, + pubIdPointed, + keccak256(referenceModuleData), + referenceModule, + keccak256(referenceModuleInitData), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getMirrorTypedDataHash( + DataTypes.MirrorData memory mirrorData, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + return + _getMirrorTypedDataHash({ + profileId: mirrorData.profileId, + profileIdPointed: mirrorData.profileIdPointed, + pubIdPointed: mirrorData.pubIdPointed, + referenceModuleData: mirrorData.referenceModuleData, + referenceModule: mirrorData.referenceModule, + referenceModuleInitData: mirrorData.referenceModuleInitData, + nonce: nonce, + deadline: deadline + }); + } + + function _getFollowTypedDataHash( + uint256 followerProfileId, + uint256[] memory idsOfProfilesToFollow, + uint256[] memory followTokenIds, + bytes[] memory datas, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + uint256 dataLength = datas.length; + bytes32[] memory dataHashes = new bytes32[](dataLength); + for (uint256 i = 0; i < dataLength; ) { + dataHashes[i] = keccak256(datas[i]); + unchecked { + ++i; + } + } + + bytes32 structHash = keccak256( + abi.encode( + FOLLOW_WITH_SIG_TYPEHASH, + followerProfileId, + keccak256(abi.encodePacked(idsOfProfilesToFollow)), + keccak256(abi.encodePacked(followTokenIds)), + keccak256(abi.encodePacked(dataHashes)), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getCollectTypedDataHash( + uint256 collectorProfileId, + uint256 publisherProfileId, + uint256 pubId, + bytes memory data, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode( + COLLECT_WITH_SIG_TYPEHASH, + collectorProfileId, + publisherProfileId, + pubId, + keccak256(data), + nonce, + deadline + ) + ); + return _calculateDigest(structHash); + } + + function _getSetDefaulProfileTypedDataHash( + address wallet, + uint256 profileId, + uint256 nonce, + uint256 deadline + ) internal view returns (bytes32) { + bytes32 structHash = keccak256( + abi.encode(SET_DEFAULT_PROFILE_WITH_SIG_TYPEHASH, wallet, profileId, nonce, deadline) + ); + return _calculateDigest(structHash); + } + + function _calculateDigest(bytes32 structHash) internal view returns (bytes32) { + bytes32 digest = keccak256(abi.encodePacked('\x19\x01', domainSeparator, structHash)); + return digest; + } + + function _getSigStruct( + uint256 pKey, + bytes32 digest, + uint256 deadline + ) internal returns (DataTypes.EIP712Signature memory) { + (uint8 v, bytes32 r, bytes32 s) = vm.sign(pKey, digest); + return DataTypes.EIP712Signature(v, r, s, deadline); + } + + function _toUint256Array(uint256 n) internal pure returns (uint256[] memory) { + uint256[] memory ret = new uint256[](1); + ret[0] = n; + return ret; + } + + function _toUint256Array(uint256 n0, uint256 n1) internal pure returns (uint256[] memory) { + uint256[] memory ret = new uint256[](2); + ret[0] = n0; + ret[1] = n1; + return ret; + } + + function _toBytesArray(bytes memory b) internal pure returns (bytes[] memory) { + bytes[] memory ret = new bytes[](1); + ret[0] = b; + return ret; + } + + function _toBytesArray(bytes memory b0, bytes memory b1) + internal + pure + returns (bytes[] memory) + { + bytes[] memory ret = new bytes[](2); + ret[0] = b0; + ret[1] = b1; + return ret; + } + + function _toBoolArray(bool b) internal pure returns (bool[] memory) { + bool[] memory ret = new bool[](1); + ret[0] = b; + return ret; + } + + function _toBoolArray(bool b0, bool b1) internal pure returns (bool[] memory) { + bool[] memory ret = new bool[](2); + ret[0] = b0; + ret[1] = b1; + return ret; + } + + // Private functions + function _buildSetDelegatedExecutorApprovalWithSigData( + address onBehalfOf, + address executor, + bool approved, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.SetDelegatedExecutorApprovalWithSigData memory) { + return + DataTypes.SetDelegatedExecutorApprovalWithSigData(onBehalfOf, executor, approved, sig); + } + + function _post(DataTypes.PostData memory postData) internal returns (uint256) { + return hub.post(postData); + } + + function _comment(DataTypes.CommentData memory commentData) internal returns (uint256) { + return hub.comment(commentData); + } + + function _mirror(DataTypes.MirrorData memory mirrorData) internal returns (uint256) { + return hub.mirror(mirrorData); + } + + function _collect( + uint256 collectorProfileId, + uint256 publisherProfileId, + uint256 pubId, + bytes memory data + ) internal returns (uint256) { + return hub.collect(collectorProfileId, publisherProfileId, pubId, data); + } + + function _postWithSig(DataTypes.PostWithSigData memory postWithSigData) + internal + returns (uint256) + { + return hub.postWithSig(postWithSigData); + } + + function _commentWithSig(DataTypes.CommentWithSigData memory commentWithSigData) + internal + returns (uint256) + { + return hub.commentWithSig(commentWithSigData); + } + + function _mirrorWithSig(DataTypes.MirrorWithSigData memory mirrorWithSigData) + internal + returns (uint256) + { + return hub.mirrorWithSig(mirrorWithSigData); + } + + function _collectWithSig(DataTypes.CollectWithSigData memory collectWithSigData) + internal + returns (uint256) + { + return hub.collectWithSig(collectWithSigData); + } + + function _follow( + address msgSender, + uint256 followerProfileId, + uint256 idOfProfileToFollow, + uint256 followTokenId, + bytes memory data + ) internal returns (uint256[] memory) { + vm.prank(msgSender); + return + hub.follow( + followerProfileId, + _toUint256Array(idOfProfileToFollow), + _toUint256Array(followTokenId), + _toBytesArray(data) + ); + } + + function _followWithSig(DataTypes.FollowWithSigData memory vars) + internal + returns (uint256[] memory) + { + return hub.followWithSig(vars); + } + + function _createProfile(address newProfileOwner) internal returns (uint256) { + DataTypes.CreateProfileData memory createProfileData = DataTypes.CreateProfileData({ + to: newProfileOwner, + imageURI: mockCreateProfileData.imageURI, + followModule: mockCreateProfileData.followModule, + followModuleInitData: mockCreateProfileData.followModuleInitData, + followNFTURI: mockCreateProfileData.followNFTURI + }); + + return hub.createProfile(createProfileData); + } + + function _setState(DataTypes.ProtocolState newState) internal { + hub.setState(newState); + } + + function _getState() internal view returns (DataTypes.ProtocolState) { + return hub.getState(); + } + + function _setEmergencyAdmin(address newEmergencyAdmin) internal { + hub.setEmergencyAdmin(newEmergencyAdmin); + } + + function _transferProfile( + address msgSender, + address from, + address to, + uint256 tokenId + ) internal { + vm.prank(msgSender); + hub.transferFrom(from, to, tokenId); + } + + function _setDelegatedExecutorApproval( + address msgSender, + address executor, + bool approved + ) internal { + vm.prank(msgSender); + hub.setDelegatedExecutorApproval(executor, approved); + } + + function _setFollowModule( + address msgSender, + uint256 profileId, + address followModule, + bytes memory followModuleInitData + ) internal { + vm.prank(msgSender); + hub.setFollowModule(profileId, followModule, followModuleInitData); + } + + function _setFollowModuleWithSig(DataTypes.SetFollowModuleWithSigData memory vars) internal { + hub.setFollowModuleWithSig(vars); + } + + function _setProfileImageURI( + address msgSender, + uint256 profileId, + string memory imageURI + ) internal { + vm.prank(msgSender); + hub.setProfileImageURI(profileId, imageURI); + } + + function _setProfileImageURIWithSig(DataTypes.SetProfileImageURIWithSigData memory vars) + internal + { + hub.setProfileImageURIWithSig(vars); + } + + function _setFollowNFTURI( + address msgSender, + uint256 profileId, + string memory followNFTURI + ) internal { + vm.prank(msgSender); + hub.setFollowNFTURI(profileId, followNFTURI); + } + + function _setFollowNFTURIWithSig(DataTypes.SetFollowNFTURIWithSigData memory vars) internal { + hub.setFollowNFTURIWithSig(vars); + } + + function _burn(address msgSender, uint256 profileId) internal { + vm.prank(msgSender); + hub.burn(profileId); + } + + function _burnWithSig(uint256 profileId, DataTypes.EIP712Signature memory sig) internal { + hub.burnWithSig(profileId, sig); + } + + function _getPub(uint256 profileId, uint256 pubId) + internal + view + returns (DataTypes.PublicationStruct memory) + { + return hub.getPub(profileId, pubId); + } + + function _getSigNonce(address signer) internal view returns (uint256) { + return hub.sigNonces(signer); + } + + function _getPubCount(uint256 profileId) internal view returns (uint256) { + return hub.getPubCount(profileId); + } + + function _getCollectCount(uint256 profileId, uint256 pubId) internal view returns (uint256) { + address collectNft = hub.getCollectNFT(profileId, pubId); + if (collectNft == address(0)) { + return 0; + } else { + return CollectNFT(collectNft).totalSupply(); + } + } +} diff --git a/test/foundry/base/TestSetup.t.sol b/test/foundry/base/TestSetup.t.sol new file mode 100644 index 0000000..ca7cf40 --- /dev/null +++ b/test/foundry/base/TestSetup.t.sol @@ -0,0 +1,291 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import 'forge-std/Test.sol'; + +// Deployments +import {ILensHub} from 'contracts/interfaces/ILensHub.sol'; +import {LensHub} from 'contracts/core/LensHub.sol'; +import {FollowNFT} from 'contracts/core/FollowNFT.sol'; +import {CollectNFT} from 'contracts/core/CollectNFT.sol'; +import {ModuleGlobals} from 'contracts/core/modules/ModuleGlobals.sol'; +import {TransparentUpgradeableProxy} from 'contracts/upgradeability/TransparentUpgradeableProxy.sol'; +import {DataTypes} from 'contracts/libraries/DataTypes.sol'; +import 'contracts/libraries/Constants.sol'; +import {Errors} from 'contracts/libraries/Errors.sol'; +import {Events} from 'contracts/libraries/Events.sol'; +import {GeneralLib} from 'contracts/libraries/GeneralLib.sol'; +import {ProfileTokenURILogic} from 'contracts/libraries/ProfileTokenURILogic.sol'; +import {MockCollectModule} from 'contracts/mocks/MockCollectModule.sol'; +import {MockReferenceModule} from 'contracts/mocks/MockReferenceModule.sol'; +import '../helpers/ForkManagement.sol'; +import '../Constants.sol'; + +contract TestSetup is Test, ForkManagement { + using stdJson for string; + + uint256 newProfileId; // TODO: We should get rid of this everywhere, and create dedicated profiles instead (see Follow tests) + + address deployer; + address governance; + address treasury; + + string constant MOCK_URI = 'ipfs://QmUXfQWe43RKx31VzA2BnbwhSMW8WuaJvszFWChD59m76U'; + + uint256 constant otherSignerKey = 0x737562; + uint256 constant profileOwnerKey = 0x04546b; + uint256 constant alienSignerKey = 0x123456; + address immutable profileOwner = vm.addr(profileOwnerKey); + address immutable otherSigner = vm.addr(otherSignerKey); + address immutable alienSigner = vm.addr(alienSignerKey); + address immutable me = address(this); + + bytes32 domainSeparator; + + uint16 TREASURY_FEE_BPS; + uint16 constant TREASURY_FEE_MAX_BPS = 10000; + + address hubProxyAddr; + CollectNFT collectNFT; + FollowNFT followNFT; + LensHub hubImpl; + TransparentUpgradeableProxy hubAsProxy; + LensHub hub; + MockCollectModule mockCollectModule; + MockReferenceModule mockReferenceModule; + ModuleGlobals moduleGlobals; + + DataTypes.CreateProfileData mockCreateProfileData; + + DataTypes.PostData mockPostData; + DataTypes.CommentData mockCommentData; + DataTypes.MirrorData mockMirrorData; + DataTypes.CollectData mockCollectData; + DataTypes.SetDefaultProfileWithSigData mockSetDefaultProfileData; + + function isEnvSet(string memory key) internal returns (bool) { + try vm.envString(key) { + return true; + } catch { + return false; + } + } + + constructor() { + // TODO: Replace with envOr when it's released + forkEnv = isEnvSet('TESTING_FORK') ? vm.envString('TESTING_FORK') : ''; + + if (bytes(forkEnv).length > 0) { + fork = true; + console.log('\n\n Testing using %s fork', forkEnv); + json = loadJson(); + + network = getNetwork(json, forkEnv); + + if (isEnvSet('FORK_BLOCK')) { + forkBlockNumber = vm.envUint('FORK_BLOCK'); + vm.createSelectFork(network, forkBlockNumber); + console.log('Fork Block number (FIXED BLOCK):', forkBlockNumber); + } else { + vm.createSelectFork(network); + forkBlockNumber = block.number; + console.log('Fork Block number:', forkBlockNumber); + } + + checkNetworkParams(json, forkEnv); + + loadBaseAddresses(forkEnv); + } else { + deployBaseContracts(); + } + ///////////////////////////////////////// Start governance actions. + vm.startPrank(governance); + + if (hub.getState() != DataTypes.ProtocolState.Unpaused) + hub.setState(DataTypes.ProtocolState.Unpaused); + + // Whitelist the test contract as a profile creator + hub.whitelistProfileCreator(me, true); + + vm.stopPrank(); + ///////////////////////////////////////// End governance actions. + } + + // TODO: Replace with forge-std/StdJson.sol::keyExists(...) when/if this PR is approved: + // https://github.com/foundry-rs/forge-std/pull/226 + function keyExists(string memory key) internal returns (bool) { + return json.parseRaw(key).length > 0; + } + + function loadBaseAddresses(string memory targetEnv) internal virtual { + bytes32 PROXY_IMPLEMENTATION_STORAGE_SLOT = bytes32( + uint256(keccak256('eip1967.proxy.implementation')) - 1 + ); + + console.log('targetEnv:', targetEnv); + + hubProxyAddr = json.readAddress(string(abi.encodePacked('.', targetEnv, '.LensHubProxy'))); + console.log('hubProxyAddr:', hubProxyAddr); + + hub = LensHub(hubProxyAddr); + + console.log('Hub:', address(hub)); + + address followNFTAddr = hub.getFollowNFTImpl(); + address collectNFTAddr = hub.getCollectNFTImpl(); + + address hubImplAddr = address( + uint160(uint256(vm.load(hubProxyAddr, PROXY_IMPLEMENTATION_STORAGE_SLOT))) + ); + console.log('Found hubImplAddr:', hubImplAddr); + hubImpl = LensHub(hubImplAddr); + followNFT = FollowNFT(followNFTAddr); + collectNFT = CollectNFT(collectNFTAddr); + hubAsProxy = TransparentUpgradeableProxy(payable(address(hub))); + moduleGlobals = ModuleGlobals( + json.readAddress(string(abi.encodePacked('.', targetEnv, '.ModuleGlobals'))) + ); + + newProfileId = _getNextProfileId(); + console.log('newProfileId:', newProfileId); + + deployer = address(1); + + governance = hub.getGovernance(); + treasury = moduleGlobals.getTreasury(); + + TREASURY_FEE_BPS = moduleGlobals.getTreasuryFee(); + } + + function deployBaseContracts() internal { + newProfileId = FIRST_PROFILE_ID; + deployer = address(1); + governance = address(2); + treasury = address(3); + + TREASURY_FEE_BPS = 50; + + ///////////////////////////////////////// Start deployments. + vm.startPrank(deployer); + + // Precompute needed addresss. + address followNFTAddr = computeCreateAddress(deployer, 1); + address collectNFTAddr = computeCreateAddress(deployer, 2); + hubProxyAddr = computeCreateAddress(deployer, 3); + + // Deploy implementation contracts. + hubImpl = new LensHub(followNFTAddr, collectNFTAddr); + followNFT = new FollowNFT(hubProxyAddr); + collectNFT = new CollectNFT(hubProxyAddr); + + // Deploy and initialize proxy. + bytes memory initData = abi.encodeCall( + hubImpl.initialize, + ('Lens Protocol Profiles', 'LPP', governance) + ); + hubAsProxy = new TransparentUpgradeableProxy(address(hubImpl), deployer, initData); + + // Cast proxy to LensHub interface. + hub = LensHub(address(hubAsProxy)); + + // Deploy the MockCollectModule. + mockCollectModule = new MockCollectModule(); + + // Deploy the MockReferenceModule. + mockReferenceModule = new MockReferenceModule(); + + moduleGlobals = new ModuleGlobals(governance, treasury, TREASURY_FEE_BPS); + + vm.stopPrank(); + ///////////////////////////////////////// End deployments. + + // Start governance actions. + vm.startPrank(governance); + + // Whitelist the FreeCollectModule. + hub.whitelistCollectModule(address(mockCollectModule), true); + + // Whitelist the MockReferenceModule. + hub.whitelistReferenceModule(address(mockReferenceModule), true); + + // End governance actions. + vm.stopPrank(); + } + + function setUp() public virtual { + // Compute the domain separator. + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256('Lens Protocol Profiles'), + EIP712_REVISION_HASH, + block.chainid, + hubProxyAddr + ) + ); + + // precompute basic profile creaton data. + mockCreateProfileData = DataTypes.CreateProfileData({ + to: profileOwner, + imageURI: MOCK_URI, + followModule: address(0), + followModuleInitData: '', + followNFTURI: MOCK_URI + }); + + // Precompute basic post data. + mockPostData = DataTypes.PostData({ + profileId: newProfileId, + contentURI: MOCK_URI, + collectModule: address(mockCollectModule), + collectModuleInitData: abi.encode(1), + referenceModule: address(0), + referenceModuleInitData: '' + }); + + // Precompute basic comment data. + mockCommentData = DataTypes.CommentData({ + profileId: newProfileId, + contentURI: MOCK_URI, + profileIdPointed: newProfileId, + pubIdPointed: FIRST_PUB_ID, + referenceModuleData: '', + collectModule: address(mockCollectModule), + collectModuleInitData: abi.encode(1), + referenceModule: address(0), + referenceModuleInitData: '' + }); + + // Precompute basic mirror data. + mockMirrorData = DataTypes.MirrorData({ + profileId: newProfileId, + profileIdPointed: newProfileId, + pubIdPointed: FIRST_PUB_ID, + referenceModuleData: '', + referenceModule: address(0), + referenceModuleInitData: '' + }); + + // Precompute basic collect data. + mockCollectData = DataTypes.CollectData({ + collectorProfileId: newProfileId, + publisherProfileId: newProfileId, + pubId: FIRST_PUB_ID, + data: '' + }); + + mockSetDefaultProfileData = DataTypes.SetDefaultProfileWithSigData({ + delegatedSigner: otherSigner, + wallet: profileOwner, + profileId: newProfileId, + sig: DataTypes.EIP712Signature({v: 0, r: bytes32(0), s: bytes32(0), deadline: 0}) // blank sig + }); + + hub.createProfile(mockCreateProfileData); + } + + // TODO: Find a better place for such helpers that have access to Hub without rekting inheritance + function _getNextProfileId() internal returns (uint256) { + return uint256(vm.load(hubProxyAddr, bytes32(uint256(PROFILE_COUNTER_SLOT)))) + 1; + } +} diff --git a/test/foundry/fork/UpgradeForkTest.t.sol b/test/foundry/fork/UpgradeForkTest.t.sol new file mode 100644 index 0000000..044c41a --- /dev/null +++ b/test/foundry/fork/UpgradeForkTest.t.sol @@ -0,0 +1,426 @@ +// This test should upgrade the forked Polygon deployment, and run a series of tests. +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol'; +import '@openzeppelin/contracts/token/ERC721/IERC721.sol'; +import 'forge-std/console2.sol'; +import '../base/BaseTest.t.sol'; +import '../../../contracts/mocks/MockReferenceModule.sol'; +import '../../../contracts/mocks/MockDeprecatedReferenceModule.sol'; +import '../../../contracts/mocks/MockCollectModule.sol'; +import '../../../contracts/mocks/MockDeprecatedCollectModule.sol'; +import '../../../contracts/mocks/MockFollowModule.sol'; +import '../../../contracts/mocks/MockDeprecatedFollowModule.sol'; +import '../../../contracts/interfaces/IERC721Time.sol'; +import '../../../contracts/interfaces/ILensMultiState.sol'; + +struct OldCreateProfileData { + address to; + string handle; + string imageURI; + address followModule; + bytes followModuleInitData; + string followNFTURI; +} + +interface IOldHub { + function createProfile(OldCreateProfileData memory vars) external returns (uint256); + + function follow(uint256[] calldata profileIds, bytes[] calldata datas) external; + + function collect( + uint256 profileId, + uint256 pubId, + bytes calldata data + ) external; + + function setDefaultProfile(uint256 profileId) external; + + function defaultProfile(address wallet) external view returns (uint256); +} + +contract UpgradeForkTest is BaseTest { + bytes32 constant ADMIN_SLOT = bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1); + address constant MOCK_DISPATCHER_ADDRESS = address(0x4546b); + address constant POLYGON_HUB_PROXY = 0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d; + address constant MUMBAI_HUB_PROXY = 0x60Ae865ee4C725cd04353b5AAb364553f56ceF82; + + uint256 polygonForkId; + uint256 mumbaiForkId; + + address mockCollectModuleAddr; + address mockFollowModuleAddr; + address mockReferenceModuleAddr; + + function setUp() public override { + if (bytes(forkEnv).length > 0) { + // TODO: Consider adding a "FORK" bool env variable to explicitly enable fork testing and not require ENVs for general tests + string memory polygonForkUrl = vm.envString('POLYGON_RPC_URL'); + string memory mumbaiForkUrl = vm.envString('MUMBAI_RPC_URL'); + + polygonForkId = vm.createFork(polygonForkUrl); + mumbaiForkId = vm.createFork(mumbaiForkUrl); + } + } + + function testUpgradePolygon() public onlyFork { + vm.selectFork(polygonForkId); + _fullRun(POLYGON_HUB_PROXY); + } + + function testUpgradeMumbai() public onlyFork { + vm.selectFork(mumbaiForkId); + _fullRun(MUMBAI_HUB_PROXY); + } + + function _fullRun(address hubProxyAddr) private { + ILensHub hub = ILensHub(hubProxyAddr); + address proxyAdmin = address(uint160(uint256(vm.load(hubProxyAddr, ADMIN_SLOT)))); + address gov = hub.getGovernance(); + + // Setup the new deployment and helper memory structs. + _forkSetup(hubProxyAddr, gov); + + // Create a profile on the old hub, set the default profile and dispatcher. + uint256 profileId = _fullCreateProfileSequence(gov, hub); + + // Post, comment, mirror. + _fullPublishSequence(profileId, gov, hub); + + // Follow, Collect. + _fullFollowCollectSequence(profileId, gov, hub); + + // Get the profile. + DataTypes.ProfileStruct memory profileStruct = hub.getProfile(profileId); + bytes memory encodedProfile = abi.encode(profileStruct); + + // Upgrade the hub. + TransparentUpgradeableProxy oldHubAsProxy = TransparentUpgradeableProxy( + payable(hubProxyAddr) + ); + vm.prank(proxyAdmin); + oldHubAsProxy.upgradeTo(address(hubImpl)); + + // Ensure governance is the same. + assertEq(hub.getGovernance(), gov); + + // Ensure profile is the same. + profileStruct = hub.getProfile(profileId); + bytes memory postUpgradeEncodedProfile = abi.encode(profileStruct); + assertEq(postUpgradeEncodedProfile, encodedProfile); + + // Create a profile on the new hub, set the default profile and dispatcher. + profileId = _fullCreateProfileSequence(gov, hub); + + // Post, comment, mirror. + _fullPublishSequence(profileId, gov, hub); + + // Follow, Collect. + _fullFollowCollectSequence(profileId, gov, hub); + + // Fourth, set new data and ensure getters return the new data (proper slots set). + vm.prank(gov); + hub.setGovernance(me); + assertEq(hub.getGovernance(), me); + } + + function _fullCreateProfileSequence(address gov, ILensHub hub) private returns (uint256) { + // In order to make this test suite evergreen, we must try setting a modern follow module since we don't know + // which version of the hub we're working with, if this fails, then we should use a deprecated one. + + // mockCreateProfileData.handle = vm.toString(IERC721Enumerable(address(hub)).totalSupply()); + mockCreateProfileData.followModule = mockFollowModuleAddr; + + uint256 profileId; + try hub.createProfile(mockCreateProfileData) returns (uint256 retProfileId) { + profileId = retProfileId; + console2.log('Profile created with modern follow module.'); + hub.setDefaultProfile(me, profileId); + assertEq(hub.getDefaultProfile(me), profileId); + } catch { + console2.log( + 'Profile creation with modern follow module failed. Attempting with deprecated module.' + ); + + address mockDeprecatedFollowModule = address(new MockDeprecatedFollowModule()); + + vm.prank(gov); + hub.whitelistFollowModule(mockDeprecatedFollowModule, true); + + // precompute basic profile creaton data. + mockCreateProfileData = DataTypes.CreateProfileData({ + to: me, + imageURI: MOCK_URI, + followModule: address(0), + followModuleInitData: abi.encode(1), + followNFTURI: MOCK_URI + }); + + OldCreateProfileData memory oldCreateProfileData = OldCreateProfileData( + mockCreateProfileData.to, + vm.toString((IERC721Enumerable(address(hub)).totalSupply())), + mockCreateProfileData.imageURI, + mockDeprecatedFollowModule, + mockCreateProfileData.followModuleInitData, + mockCreateProfileData.followNFTURI + ); + + oldCreateProfileData.followModule = mockDeprecatedFollowModule; + profileId = IOldHub(address(hub)).createProfile(oldCreateProfileData); + IOldHub(address(hub)).setDefaultProfile(profileId); + assertEq(IOldHub(address(hub)).defaultProfile(me), profileId); + } + hub.setDispatcher(profileId, MOCK_DISPATCHER_ADDRESS); + assertEq(hub.getDispatcher(profileId), MOCK_DISPATCHER_ADDRESS); + return profileId; + } + + function _fullPublishSequence( + uint256 profileId, + address gov, + ILensHub hub + ) private { + // First check if the new interface works, if not, use the old interface. + + // Set the proper initial params, these must be redundantly reset as they may have been set + // to different values in memory. + mockPostData.profileId = profileId; + mockPostData.collectModule = mockCollectModuleAddr; + mockPostData.referenceModule = mockReferenceModuleAddr; + + mockCommentData.profileId = profileId; + mockCommentData.profileIdPointed = profileId; + + mockMirrorData.profileId = profileId; + mockMirrorData.profileIdPointed = profileId; + + // Set the modern reference module, the modern collect module is already set by default. + mockPostData.referenceModule = mockReferenceModuleAddr; + + try hub.post(mockPostData) returns (uint256 retPubId) { + console2.log( + 'Post published with modern collect and reference module, continuing with modern modules.' + ); + uint256 postId = retPubId; + assertEq(postId, 1); + + mockCommentData.collectModule = mockCollectModuleAddr; + mockCommentData.referenceModule = mockReferenceModuleAddr; + mockMirrorData.referenceModule = mockReferenceModuleAddr; + + // Validate post. + assertEq(postId, 1); + DataTypes.PublicationStruct memory pub = hub.getPub(profileId, postId); + assertEq(pub.profileIdPointed, 0); + assertEq(pub.pubIdPointed, 0); + assertEq(pub.contentURI, mockPostData.contentURI); + assertEq(pub.referenceModule, mockPostData.referenceModule); + assertEq(pub.collectModule, mockPostData.collectModule); + assertEq(pub.collectNFT, address(0)); + + // Comment. + uint256 commentId = hub.comment(mockCommentData); + + // Validate comment. + assertEq(commentId, 2); + pub = hub.getPub(profileId, commentId); + assertEq(pub.profileIdPointed, mockCommentData.profileIdPointed); + assertEq(pub.pubIdPointed, mockCommentData.pubIdPointed); + assertEq(pub.contentURI, mockCommentData.contentURI); + assertEq(pub.referenceModule, mockCommentData.referenceModule); + assertEq(pub.collectModule, mockCommentData.collectModule); + assertEq(pub.collectNFT, address(0)); + + // Mirror. + uint256 mirrorId = hub.mirror(mockMirrorData); + + // Validate mirror. + assertEq(mirrorId, 3); + pub = hub.getPub(profileId, mirrorId); + assertEq(pub.profileIdPointed, mockMirrorData.profileIdPointed); + assertEq(pub.pubIdPointed, mockMirrorData.pubIdPointed); + assertEq(pub.contentURI, ''); + assertEq(pub.referenceModule, mockMirrorData.referenceModule); + assertEq(pub.collectModule, address(0)); + assertEq(pub.collectNFT, address(0)); + } catch { + console2.log( + 'Post with modern collect and reference module failed, Attempting with deprecated modules' + ); + + address mockDeprecatedCollectModule = address(new MockDeprecatedCollectModule()); + address mockDeprecatedReferenceModule = address(new MockDeprecatedReferenceModule()); + + vm.startPrank(gov); + hub.whitelistCollectModule(mockDeprecatedCollectModule, true); + hub.whitelistReferenceModule(mockDeprecatedReferenceModule, true); + vm.stopPrank(); + + // Post. + mockPostData.collectModule = mockDeprecatedCollectModule; + mockPostData.referenceModule = mockDeprecatedReferenceModule; + uint256 postId = hub.post(mockPostData); + + // Validate post. + assertEq(postId, 1); + DataTypes.PublicationStruct memory pub = hub.getPub(profileId, postId); + assertEq(pub.profileIdPointed, 0); + assertEq(pub.pubIdPointed, 0); + assertEq(pub.contentURI, mockPostData.contentURI); + assertEq(pub.referenceModule, mockPostData.referenceModule); + assertEq(pub.collectModule, mockPostData.collectModule); + assertEq(pub.collectNFT, address(0)); + + // Comment. + mockCommentData.collectModule = mockDeprecatedCollectModule; + mockCommentData.referenceModule = mockDeprecatedReferenceModule; + uint256 commentId = hub.comment(mockCommentData); + + // Validate comment. + assertEq(commentId, 2); + pub = hub.getPub(profileId, commentId); + assertEq(pub.profileIdPointed, mockCommentData.profileIdPointed); + assertEq(pub.pubIdPointed, mockCommentData.pubIdPointed); + assertEq(pub.contentURI, mockCommentData.contentURI); + assertEq(pub.referenceModule, mockCommentData.referenceModule); + assertEq(pub.collectModule, mockCommentData.collectModule); + assertEq(pub.collectNFT, address(0)); + + // Mirror. + mockMirrorData.referenceModule = mockDeprecatedReferenceModule; + uint256 mirrorId = hub.mirror(mockMirrorData); + + // Validate mirror. + assertEq(mirrorId, 3); + pub = hub.getPub(profileId, mirrorId); + assertEq(pub.profileIdPointed, mockMirrorData.profileIdPointed); + assertEq(pub.pubIdPointed, mockMirrorData.pubIdPointed); + assertEq(pub.contentURI, ''); + assertEq(pub.referenceModule, mockMirrorData.referenceModule); + assertEq(pub.collectModule, address(0)); + assertEq(pub.collectNFT, address(0)); + } + } + + function _fullFollowCollectSequence( + uint256 profileId, + address gov, + ILensHub hub + ) private { + // First check if the new interface works, if not, use the old interface. + uint256[] memory profileIds = new uint256[](1); + profileIds[0] = profileId; + uint256[] memory followTokenIds = new uint256[](1); + followTokenIds[0] = 0; + bytes[] memory datas = new bytes[](1); + datas[0] = ''; + + uint256 secondProfileId = _fullCreateProfileSequence(gov, hub); + + try hub.follow(secondProfileId, profileIds, followTokenIds, datas) { + console2.log( + 'Follow with modern interface succeeded, continuing with modern interface.' + ); + hub.collect(profileId, profileId, 1, ''); + hub.collect(profileId, profileId, 2, ''); + hub.collect(profileId, profileId, 3, ''); + } catch { + console2.log( + 'Follow with modern interface failed, proceeding with deprecated interface.' + ); + IOldHub(address(hub)).follow(profileIds, datas); + IOldHub(address(hub)).collect(profileId, 1, ''); + IOldHub(address(hub)).collect(profileId, 2, ''); + IOldHub(address(hub)).collect(profileId, 3, ''); + } + } + + function _forkSetup(address hubProxyAddr, address gov) private { + // Start deployments. + vm.startPrank(deployer); + + // Precompute needed addresss. + address followNFTAddr = computeCreateAddress(deployer, 1); + address collectNFTAddr = computeCreateAddress(deployer, 2); + + // Deploy implementation contracts. + hubImpl = new LensHub(followNFTAddr, collectNFTAddr); + followNFT = new FollowNFT(hubProxyAddr); + collectNFT = new CollectNFT(hubProxyAddr); + + // Deploy the mock modules. + mockCollectModuleAddr = address(new MockCollectModule()); + mockReferenceModuleAddr = address(new MockReferenceModule()); + mockFollowModuleAddr = address(new MockFollowModule()); + + // End deployments. + vm.stopPrank(); + + hub = LensHub(hubProxyAddr); + // Start gov actions. + vm.startPrank(gov); + hub.whitelistProfileCreator(me, true); + hub.whitelistFollowModule(mockFollowModuleAddr, true); + hub.whitelistCollectModule(mockCollectModuleAddr, true); + hub.whitelistReferenceModule(mockReferenceModuleAddr, true); + + // End gov actions. + vm.stopPrank(); + + // Compute the domain separator. + domainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256('Lens Protocol Profiles'), + EIP712_REVISION_HASH, + block.chainid, + hubProxyAddr + ) + ); + + // NOTE: Structs are invalid as-is. Handle and modules must be set on the fly. + + // precompute basic profile creaton data. + mockCreateProfileData = DataTypes.CreateProfileData({ + to: me, + imageURI: MOCK_URI, + followModule: address(0), + followModuleInitData: abi.encode(1), + followNFTURI: MOCK_URI + }); + + // Precompute basic post data. + mockPostData = DataTypes.PostData({ + profileId: 0, + contentURI: MOCK_URI, + collectModule: address(0), + collectModuleInitData: abi.encode(1), + referenceModule: address(0), + referenceModuleInitData: abi.encode(1) + }); + + // Precompute basic comment data. + mockCommentData = DataTypes.CommentData({ + profileId: 0, + contentURI: MOCK_URI, + profileIdPointed: newProfileId, + pubIdPointed: 1, + referenceModuleData: '', + collectModule: address(0), + collectModuleInitData: abi.encode(1), + referenceModule: address(0), + referenceModuleInitData: abi.encode(1) + }); + + // Precompute basic mirror data. + mockMirrorData = DataTypes.MirrorData({ + profileId: 0, + profileIdPointed: newProfileId, + pubIdPointed: 1, + referenceModuleData: '', + referenceModule: address(0), + referenceModuleInitData: abi.encode(1) + }); + } +} diff --git a/test/foundry/helpers/CollectingHelpers.sol b/test/foundry/helpers/CollectingHelpers.sol new file mode 100644 index 0000000..c67a358 --- /dev/null +++ b/test/foundry/helpers/CollectingHelpers.sol @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import '../base/TestSetup.t.sol'; +import 'forge-std/Test.sol'; +import 'contracts/libraries/DataTypes.sol'; + +contract CollectingHelpers is TestSetup { + CollectNFT _collectNftAfter; + + function _checkCollectNFTBefore() internal view returns (uint256) { + // collect NFT doesn't exist yet + + address collectNftAddress = hub.getCollectNFT( + mockCollectData.publisherProfileId, + mockCollectData.pubId + ); + + // returns nft ID or 0 if no collect nft yet + if (collectNftAddress != address(0)) { + return CollectNFT(collectNftAddress).totalSupply(); + } else { + return 0; + } + } + + function _checkCollectNFTAfter(uint256 nftId, uint256 expectedNftId) internal { + _collectNftAfter = CollectNFT( + hub.getCollectNFT(mockCollectData.publisherProfileId, mockCollectData.pubId) + ); + + (uint256 profileId, uint256 pubId) = _collectNftAfter.getSourcePublicationPointer(); + assertEq(profileId, mockCollectData.publisherProfileId); + assertEq(pubId, mockCollectData.pubId); + + assertEq(nftId, expectedNftId); + assertEq( + _collectNftAfter.ownerOf(mockCollectData.pubId), + hub.ownerOf(mockCollectData.collectorProfileId) + ); + assertEq(_collectNftAfter.name(), _expectedName()); + assertEq(_collectNftAfter.symbol(), _expectedSymbol()); + } + + function _expectedName() internal virtual returns (string memory) { + return + string( + abi.encodePacked( + vm.toString(mockCollectData.publisherProfileId), + COLLECT_NFT_NAME_INFIX, + vm.toString(mockCollectData.pubId) + ) + ); + } + + function _expectedSymbol() internal virtual returns (string memory) { + return + string( + abi.encodePacked( + vm.toString(mockCollectData.publisherProfileId), + COLLECT_NFT_SYMBOL_INFIX, + vm.toString(mockCollectData.pubId) + ) + ); + } +} diff --git a/test/foundry/helpers/ForkManagement.sol b/test/foundry/helpers/ForkManagement.sol new file mode 100644 index 0000000..8f93aec --- /dev/null +++ b/test/foundry/helpers/ForkManagement.sol @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import 'forge-std/Script.sol'; + +contract ForkManagement is Script { + using stdJson for string; + + string forkEnv; + bool fork; + string network; + string json; + uint256 forkBlockNumber; + + modifier onlyFork() { + if (bytes(forkEnv).length == 0) return; + _; + } + + function loadJson() internal returns (string memory) { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, '/addresses.json'); + string memory json = vm.readFile(path); + return json; + } + + function checkNetworkParams(string memory json, string memory targetEnv) + internal + returns (string memory network, uint256 chainId) + { + network = json.readString(string.concat('.', targetEnv, '.network')); + chainId = json.readUint(string.concat('.', targetEnv, '.chainId')); + + console.log('\nTarget environment:', targetEnv); + console.log('Network:', network); + if (block.chainid != chainId) revert('Wrong chainId'); + console.log('ChainId:', chainId); + } + + function getNetwork(string memory json, string memory targetEnv) + internal + returns (string memory) + { + return json.readString(string.concat('.', targetEnv, '.network')); + } +} diff --git a/test/foundry/helpers/PublishingHelpers.sol b/test/foundry/helpers/PublishingHelpers.sol new file mode 100644 index 0000000..779ed47 --- /dev/null +++ b/test/foundry/helpers/PublishingHelpers.sol @@ -0,0 +1,64 @@ +import 'forge-std/Test.sol'; +import 'contracts/libraries/DataTypes.sol'; + +contract PublishingHelpers is Test { + function _verifyPublication( + DataTypes.PublicationStruct memory pub, + DataTypes.PublicationStruct memory expectedPub + ) internal { + assertEq(pub.profileIdPointed, expectedPub.profileIdPointed); + assertEq(pub.pubIdPointed, expectedPub.pubIdPointed); + assertEq(pub.contentURI, expectedPub.contentURI); + assertEq(pub.referenceModule, expectedPub.referenceModule); + assertEq(pub.collectModule, expectedPub.collectModule); + assertEq(pub.collectNFT, expectedPub.collectNFT); + } + + function _expectedPubFromInitData(DataTypes.PostData memory postData) + internal + pure + returns (DataTypes.PublicationStruct memory) + { + return + DataTypes.PublicationStruct({ + profileIdPointed: 0, + pubIdPointed: 0, + contentURI: postData.contentURI, + referenceModule: postData.referenceModule, + collectModule: postData.collectModule, + collectNFT: address(0) + }); + } + + function _expectedPubFromInitData(DataTypes.CommentData memory commentData) + internal + pure + returns (DataTypes.PublicationStruct memory) + { + return + DataTypes.PublicationStruct({ + profileIdPointed: commentData.profileIdPointed, + pubIdPointed: commentData.pubIdPointed, + contentURI: commentData.contentURI, + referenceModule: commentData.referenceModule, + collectModule: commentData.collectModule, + collectNFT: address(0) + }); + } + + function _expectedPubFromInitData(DataTypes.MirrorData memory mirrorData) + internal + pure + returns (DataTypes.PublicationStruct memory) + { + return + DataTypes.PublicationStruct({ + profileIdPointed: mirrorData.profileIdPointed, + pubIdPointed: mirrorData.pubIdPointed, + contentURI: '', + referenceModule: mirrorData.referenceModule, + collectModule: address(0), + collectNFT: address(0) + }); + } +} diff --git a/test/foundry/helpers/SignatureHelpers.sol b/test/foundry/helpers/SignatureHelpers.sol new file mode 100644 index 0000000..63ad304 --- /dev/null +++ b/test/foundry/helpers/SignatureHelpers.sol @@ -0,0 +1,174 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import '../../../contracts/libraries/DataTypes.sol'; + +contract SigSetup { + uint256 nonce; + uint256 deadline; + + function setUp() public virtual { + nonce = 0; + deadline = type(uint256).max; + } +} + +contract SignatureHelpers { + // Private functions + function _buildPostWithSigData( + address delegatedSigner, + uint256 profileId, + string memory contentURI, + address collectModule, + bytes memory collectModuleInitData, + address referenceModule, + bytes memory referenceModuleInitData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.PostWithSigData memory) { + return + DataTypes.PostWithSigData( + delegatedSigner, + profileId, + contentURI, + collectModule, + collectModuleInitData, + referenceModule, + referenceModuleInitData, + sig + ); + } + + function _buildPostWithSigData( + address delegatedSigner, + DataTypes.PostData memory postData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.PostWithSigData memory) { + return + _buildPostWithSigData( + delegatedSigner, + postData.profileId, + postData.contentURI, + postData.collectModule, + postData.collectModuleInitData, + postData.referenceModule, + postData.referenceModuleInitData, + sig + ); + } + + function _buildCommentWithSigData( + address delegatedSigner, + uint256 profileId, + string memory contentURI, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes memory referenceModuleData, + address collectModule, + bytes memory collectModuleInitData, + address referenceModule, + bytes memory referenceModuleInitData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.CommentWithSigData memory) { + return + DataTypes.CommentWithSigData( + delegatedSigner, + profileId, + contentURI, + profileIdPointed, + pubIdPointed, + referenceModuleData, + collectModule, + collectModuleInitData, + referenceModule, + referenceModuleInitData, + sig + ); + } + + function _buildCommentWithSigData( + address delegatedSigner, + DataTypes.CommentData memory commentData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.CommentWithSigData memory) { + return + _buildCommentWithSigData({ + delegatedSigner: delegatedSigner, + profileId: commentData.profileId, + contentURI: commentData.contentURI, + profileIdPointed: commentData.profileIdPointed, + pubIdPointed: commentData.pubIdPointed, + referenceModuleData: commentData.referenceModuleData, + collectModule: commentData.collectModule, + collectModuleInitData: commentData.collectModuleInitData, + referenceModule: commentData.referenceModule, + referenceModuleInitData: commentData.referenceModuleInitData, + sig: sig + }); + } + + function _buildMirrorWithSigData( + address delegatedSigner, + uint256 profileId, + uint256 profileIdPointed, + uint256 pubIdPointed, + bytes memory referenceModuleData, + address referenceModule, + bytes memory referenceModuleInitData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.MirrorWithSigData memory) { + return + DataTypes.MirrorWithSigData( + delegatedSigner, + profileId, + profileIdPointed, + pubIdPointed, + referenceModuleData, + referenceModule, + referenceModuleInitData, + sig + ); + } + + function _buildMirrorWithSigData( + address delegatedSigner, + DataTypes.MirrorData memory mirrorData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.MirrorWithSigData memory) { + return + _buildMirrorWithSigData({ + delegatedSigner: delegatedSigner, + profileId: mirrorData.profileId, + profileIdPointed: mirrorData.profileIdPointed, + pubIdPointed: mirrorData.pubIdPointed, + referenceModuleData: mirrorData.referenceModuleData, + referenceModule: mirrorData.referenceModule, + referenceModuleInitData: mirrorData.referenceModuleInitData, + sig: sig + }); + } + + function _buildCollectWithSigData( + address delegatedSigner, + DataTypes.CollectData memory collectData, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.CollectWithSigData memory) { + return + DataTypes.CollectWithSigData({ + delegatedSigner: delegatedSigner, + collectorProfileId: collectData.collectorProfileId, + publisherProfileId: collectData.publisherProfileId, + pubId: collectData.pubId, + data: collectData.data, + sig: sig + }); + } + + function _buildSetDefaultProfileWithSigData( + address delegatedSigner, + address wallet, + uint256 profileId, + DataTypes.EIP712Signature memory sig + ) internal pure returns (DataTypes.SetDefaultProfileWithSigData memory) { + return DataTypes.SetDefaultProfileWithSigData(delegatedSigner, wallet, profileId, sig); + } +} diff --git a/test/foundry/initial-conditions/FollowNFTInitialConditionsTest.t.sol b/test/foundry/initial-conditions/FollowNFTInitialConditionsTest.t.sol new file mode 100644 index 0000000..fa2fab9 --- /dev/null +++ b/test/foundry/initial-conditions/FollowNFTInitialConditionsTest.t.sol @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import './../FollowNFTTest.t.sol'; + +contract FollowNFTInitialConditionsTest is FollowNFTTest { + function testFirstFollowTokenHasIdOne() public { + uint256 profileIdToFollow = _createProfile(me); + + uint256 assignedTokenId = _follow( + followerProfileOwner, + followerProfileId, + profileIdToFollow, + 0, + '' + )[0]; + + assertEq(assignedTokenId, 1); + } +} diff --git a/test/helpers/errors.ts b/test/helpers/errors.ts index ecb3185..682f986 100644 --- a/test/helpers/errors.ts +++ b/test/helpers/errors.ts @@ -4,19 +4,18 @@ export const ERRORS = { SIGNATURE_EXPIRED: 'SignatureExpired()', ZERO_SPENDER: 'ZeroSpender()', SIGNATURE_INVALID: 'SignatureInvalid()', + EXECUTOR_INVALID: 'ExecutorInvalid()', NOT_OWNER_OR_APPROVED: 'NotOwnerOrApproved()', NOT_HUB: 'NotHub()', TOKEN_DOES_NOT_EXIST: 'TokenDoesNotExist()', - CALLER_NOT_WHITELSITED_MODULE: 'CallerNotWhitelistedModule()', NOT_GOVERNANCE: 'NotGovernance()', NOT_GOVERNANCE_OR_EMERGENCY_ADMIN: 'NotGovernanceOrEmergencyAdmin()', - EMERGENCY_ADMIN_CANNOT_UNPAUSE: 'EmergencyAdminCannotUnpause()', + EMERGENCY_ADMIN_CAN_ONLY_PAUSE_FURTHER: 'EmergencyAdminCanOnlyPauseFurther()', COLLECT_MODULE_NOT_WHITELISTED: 'CollectModuleNotWhitelisted()', FOLLOW_MODULE_NOT_WHITELISTED: 'FollowModuleNotWhitelisted()', REFERENCE_MODULE_NOT_WHITELISTED: 'ReferenceModuleNotWhitelisted()', PROFILE_CREATOR_NOT_WHITELISTED: 'ProfileCreatorNotWhitelisted()', NOT_PROFILE_OWNER: 'NotProfileOwner()', - NOT_PROFILE_OWNER_OR_DISPATCHER: 'NotProfileOwnerOrDispatcher()', PUBLICATION_DOES_NOT_EXIST: 'PublicationDoesNotExist()', PROFILE_HANDLE_TAKEN: 'HandleTaken()', INVALID_HANDLE_LENGTH: 'HandleLengthInvalid()', @@ -36,9 +35,11 @@ export const ERRORS = { ARRAY_MISMATCH: 'ArrayMismatch()', CANNOT_COMMENT_ON_SELF: 'CannotCommentOnSelf', NOT_DISPATCHER: 'NotDispatcher()', - ERC721_NOT_OWN: 'ERC721: transfer of token that is not own', - ERC721_TRANSFER_NOT_OWNER_OR_APPROVED: 'ERC721: transfer caller is not owner nor approved', - ERC721_QUERY_FOR_NONEXISTENT_TOKEN: 'ERC721: owner query for nonexistent token', + + // ERC721Time + ERC721Enumerable errors + ERC721_NOT_OWN: 'ERC721Time_TransferOfTokenThatIsNotOwn()', + ERC721_TRANSFER_NOT_OWNER_OR_APPROVED: 'ERC721Time_TransferCallerNotOwnerOrApproved()', + ERC721_OWNER_QUERY_FOR_NONEXISTENT_TOKEN: 'ERC721Time_OwnerQueryForNonexistantToken()', ERC20_TRANSFER_EXCEEDS_ALLOWANCE: 'ERC20: transfer amount exceeds allowance', ERC20_INSUFFICIENT_ALLOWANCE: 'ERC20: insufficient allowance', NO_SELECTOR: @@ -46,6 +47,6 @@ export const ERRORS = { PAUSED: 'Paused()', PUBLISHING_PAUSED: 'PublishingPaused()', NO_REASON_ABI_DECODE: - "Transaction reverted and Hardhat couldn't infer the reason. Please report this to help us improve Hardhat.", + "Transaction reverted and Hardhat couldn't infer the reason.", INVALID_PARAMETER: 'InvalidParameter()', }; diff --git a/test/helpers/utils.ts b/test/helpers/utils.ts index ca4b273..5be7fd6 100644 --- a/test/helpers/utils.ts +++ b/test/helpers/utils.ts @@ -12,7 +12,15 @@ import { } from '../__setup.spec'; import { expect } from 'chai'; import { HARDHAT_CHAINID, MAX_UINT256 } from './constants'; -import { BytesLike, hexlify, keccak256, RLP, toUtf8Bytes } from 'ethers/lib/utils'; +import { + BytesLike, + concat, + hexlify, + keccak256, + RLP, + toUtf8Bytes, + _TypedDataEncoder, +} from 'ethers/lib/utils'; import { LensHub__factory } from '../../typechain-types'; import { TransactionReceipt, TransactionResponse } from '@ethersproject/providers'; import hre, { ethers } from 'hardhat'; @@ -247,6 +255,18 @@ export async function getPermitParts( return await getSig(msgParams); } +export async function getPermitMessageParts( + nft: string, + name: string, + spender: string, + tokenId: BigNumberish, + nonce: number, + deadline: string +): Promise<{ v: number; r: string; s: string }> { + const msgParams = buildPermitParams(nft, name, spender, tokenId, nonce, deadline); + return getMessageSig(msgParams); +} + export async function getPermitForAllParts( nft: string, name: string, @@ -393,6 +413,29 @@ export async function getPostWithSigParts( return await getSig(msgParams); } +export async function getPostWithSigMessageParts( + profileId: BigNumberish, + contentURI: string, + collectModule: string, + collectModuleInitData: Bytes | string, + referenceModule: string, + referenceModuleInitData: Bytes | string, + nonce: number, + deadline: string +): Promise<{ v: number; r: string; s: string }> { + const msgParams = buildPostWithSigParams( + profileId, + contentURI, + collectModule, + collectModuleInitData, + referenceModule, + referenceModuleInitData, + nonce, + deadline + ); + return getMessageSig(msgParams); +} + export async function getCommentWithSigParts( profileId: BigNumberish, contentURI: string, @@ -536,8 +579,12 @@ export async function followReturningTokenIds({ tokenIds = await lensHub.connect(sender).callStatic.followWithSig(vars); await expect(lensHub.connect(sender).followWithSig(vars)).to.not.be.reverted; } else { - tokenIds = await lensHub.connect(sender).callStatic.follow(vars.profileIds, vars.datas); - await expect(lensHub.connect(sender).follow(vars.profileIds, vars.datas)).to.not.be.reverted; + tokenIds = await lensHub + .connect(sender) + .callStatic.follow(await sender.getAddress(), vars.profileIds, vars.datas); + await expect( + lensHub.connect(sender).follow(await sender.getAddress(), vars.profileIds, vars.datas) + ).to.not.be.reverted; } return tokenIds; } @@ -564,9 +611,12 @@ export async function collectReturningTokenIds({ } else { tokenId = await lensHub .connect(sender) - .callStatic.collect(vars.profileId, vars.pubId, vars.data); - await expect(lensHub.connect(sender).collect(vars.profileId, vars.pubId, vars.data)).to.not.be - .reverted; + .callStatic.collect(await sender.getAddress(), vars.profileId, vars.pubId, vars.data); + await expect( + lensHub + .connect(sender) + .collect(await sender.getAddress(), vars.profileId, vars.pubId, vars.data) + ).to.not.be.reverted; } return tokenId; } @@ -1107,6 +1157,20 @@ async function getSig(msgParams: { return utils.splitSignature(sig); } +async function getMessageSig(msgParams: { + domain: any; + types: any; + value: any; +}): Promise<{ v: number; r: string; s: string }> { + const digest = _TypedDataEncoder.hash(msgParams.domain, msgParams.types, msgParams.value); + return utils.splitSignature(testWallet._signingKey().signDigest(hashMessage(digest))); +} + +const messagePrefix = '\x19Ethereum Signed Message:\n32'; +function hashMessage(message: string | Bytes): string { + return keccak256(concat([toUtf8Bytes(messagePrefix), message])); +} + function domain(): { name: string; version: string; chainId: number; verifyingContract: string } { return { name: LENS_HUB_NFT_NAME, diff --git a/test/hub/interactions/collecting.spec.ts b/test/hub/interactions/collecting.spec.ts deleted file mode 100644 index 9ed6fe2..0000000 --- a/test/hub/interactions/collecting.spec.ts +++ /dev/null @@ -1,543 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { CollectNFT__factory, FollowNFT__factory } from '../../../typechain-types'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - cancelWithPermitForAll, - collectReturningTokenIds, - getAbbreviation, - getCollectWithSigParts, - getTimestamp, -} from '../../helpers/utils'; -import { - lensHub, - freeCollectModule, - FIRST_PROFILE_ID, - governance, - makeSuiteCleanRoom, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - testWallet, - userAddress, - userTwo, - userTwoAddress, - MOCK_FOLLOW_NFT_URI, - abiCoder, - user, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Collecting', function () { - beforeEach(async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Generic', function () { - context('Negatives', function () { - it('UserTwo should fail to collect without being a follower', async function () { - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('user two should follow, then transfer the followNFT and fail to collect', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNftAddr = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - await expect( - FollowNFT__factory.connect(followNftAddr, userTwo).transferFrom( - userTwoAddress, - userAddress, - 1 - ) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - }); - - context('Scenarios', function () { - it('Collecting should work if the collector is the publication owner even when he is not following himself and follow NFT was not deployed', async function () { - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('Collecting should work if the collector is the publication owner even when he is not following himself and follow NFT was deployed', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.transferFrom(userAddress, userTwoAddress, 1)).to.not.be.reverted; - - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('Should return the expected token IDs when collecting publications', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - - expect( - await collectReturningTokenIds({ - vars: { - profileId: FIRST_PROFILE_ID, - pubId: 1, - data: [], - }, - }) - ).to.eq(1); - - expect( - await collectReturningTokenIds({ - sender: userTwo, - vars: { - profileId: FIRST_PROFILE_ID, - pubId: 1, - data: [], - }, - }) - ).to.eq(2); - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - expect( - await collectReturningTokenIds({ - vars: { - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }, - }) - ).to.eq(3); - - expect( - await collectReturningTokenIds({ - vars: { - profileId: FIRST_PROFILE_ID, - pubId: 1, - data: [], - }, - }) - ).to.eq(4); - }); - - it('UserTwo should follow, then collect, receive a collect NFT with the expected properties', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - const timestamp = await getTimestamp(); - - const collectNFTAddr = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - expect(collectNFTAddr).to.not.eq(ZERO_ADDRESS); - const collectNFT = CollectNFT__factory.connect(collectNFTAddr, userTwo); - const id = await collectNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const name = await collectNFT.name(); - const symbol = await collectNFT.symbol(); - const pointer = await collectNFT.getSourcePublicationPointer(); - const owner = await collectNFT.ownerOf(id); - const mintTimestamp = await collectNFT.mintTimestampOf(id); - const tokenData = await collectNFT.tokenDataOf(id); - - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - - expect(id).to.eq(1); - expect(name).to.eq(expectedName); - expect(symbol).to.eq(expectedSymbol); - expect(pointer[0]).to.eq(FIRST_PROFILE_ID); - expect(pointer[1]).to.eq(1); - expect(owner).to.eq(userTwoAddress); - expect(tokenData.owner).to.eq(userTwoAddress); - expect(tokenData.mintTimestamp).to.eq(timestamp); - expect(mintTimestamp).to.eq(timestamp); - }); - - it('UserTwo should follow, then mirror, then collect on their mirror, receive a collect NFT with expected properties', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'mockhandle', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, [])).to.not.be.reverted; - - const collectNFTAddr = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - expect(collectNFTAddr).to.not.eq(ZERO_ADDRESS); - const collectNFT = CollectNFT__factory.connect(collectNFTAddr, userTwo); - const id = await collectNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const name = await collectNFT.name(); - const symbol = await collectNFT.symbol(); - const pointer = await collectNFT.getSourcePublicationPointer(); - - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - expect(id).to.eq(1); - expect(name).to.eq(expectedName); - expect(symbol).to.eq(expectedSymbol); - expect(pointer[0]).to.eq(FIRST_PROFILE_ID); - expect(pointer[1]).to.eq(1); - }); - - it('UserTwo should follow, then mirror, mirror their mirror then collect on their latest mirror, receive a collect NFT with expected properties', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'mockhandle', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: secondProfileId, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(secondProfileId, 2, [])).to.not.be.reverted; - - const collectNFTAddr = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - expect(collectNFTAddr).to.not.eq(ZERO_ADDRESS); - const collectNFT = CollectNFT__factory.connect(collectNFTAddr, userTwo); - const id = await collectNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const name = await collectNFT.name(); - const symbol = await collectNFT.symbol(); - const pointer = await collectNFT.getSourcePublicationPointer(); - - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - expect(id).to.eq(1); - expect(name).to.eq(expectedName); - expect(symbol).to.eq(expectedSymbol); - expect(pointer[0]).to.eq(FIRST_PROFILE_ID); - expect(pointer[1]).to.eq(1); - }); - }); - }); - - context('Meta-tx', function () { - context('Negatives', function () { - it('TestWallet should fail to collect with sig with signature deadline mismatch', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts(FIRST_PROFILE_ID, '1', [], nonce, '0'); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to collect with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts(FIRST_PROFILE_ID, '1', [], nonce, '0'); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('TestWallet should fail to collect with sig with invalid nonce', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce + 1, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to collect with sig without being a follower', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('TestWallet should sign attempt to collect with sig, cancel via empty permitForAll, fail to collect with sig', async function () { - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should follow, then collect with sig, receive a collect NFT with expected properties', async function () { - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const collectNFTAddr = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - expect(collectNFTAddr).to.not.eq(ZERO_ADDRESS); - const collectNFT = CollectNFT__factory.connect(collectNFTAddr, userTwo); - const id = await collectNFT.tokenOfOwnerByIndex(testWallet.address, 0); - const name = await collectNFT.name(); - const symbol = await collectNFT.symbol(); - const pointer = await collectNFT.getSourcePublicationPointer(); - - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - expect(id).to.eq(1); - expect(name).to.eq(expectedName); - expect(symbol).to.eq(expectedSymbol); - expect(pointer[0]).to.eq(FIRST_PROFILE_ID); - expect(pointer[1]).to.eq(1); - }); - - it('TestWallet should follow, mirror, then collect with sig on their mirror', async function () { - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: 'mockhandle', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - secondProfileId.toString(), - '1', - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: secondProfileId, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const collectNFTAddr = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - expect(collectNFTAddr).to.not.eq(ZERO_ADDRESS); - const collectNFT = CollectNFT__factory.connect(collectNFTAddr, userTwo); - const id = await collectNFT.tokenOfOwnerByIndex(testWallet.address, 0); - const name = await collectNFT.name(); - const symbol = await collectNFT.symbol(); - const pointer = await collectNFT.getSourcePublicationPointer(); - - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - expect(id).to.eq(1); - expect(name).to.eq(expectedName); - expect(symbol).to.eq(expectedSymbol); - expect(pointer[0]).to.eq(FIRST_PROFILE_ID); - expect(pointer[1]).to.eq(1); - }); - }); - }); -}); diff --git a/test/hub/interactions/following.spec.ts b/test/hub/interactions/following.spec.ts deleted file mode 100644 index d7e494f..0000000 --- a/test/hub/interactions/following.spec.ts +++ /dev/null @@ -1,364 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { BigNumber } from 'ethers'; -import { FollowNFT__factory } from '../../../typechain-types'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - cancelWithPermitForAll, - expectEqualArrays, - followReturningTokenIds, - getAbbreviation, - getFollowWithSigParts, - getTimestamp, -} from '../../helpers/utils'; -import { - lensHub, - FIRST_PROFILE_ID, - makeSuiteCleanRoom, - MOCK_PROFILE_HANDLE, - testWallet, - user, - userTwo, - userTwoAddress, - MOCK_PROFILE_URI, - userAddress, - MOCK_FOLLOW_NFT_URI, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Following', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - context('Generic', function () { - context('Negatives', function () { - it('UserTwo should fail to follow a nonexistent profile', async function () { - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID + 1], [[]]) - ).to.be.revertedWith(ERRORS.TOKEN_DOES_NOT_EXIST); - }); - - it('UserTwo should fail to follow with array mismatch', async function () { - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID, FIRST_PROFILE_ID], [[]]) - ).to.be.revertedWith(ERRORS.ARRAY_MISMATCH); - }); - - it('UserTwo should fail to follow a profile that has been burned', async function () { - await expect(lensHub.burn(FIRST_PROFILE_ID)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith( - ERRORS.TOKEN_DOES_NOT_EXIST - ); - }); - }); - - context('Scenarios', function () { - it('UserTwo should follow profile 1, receive a followNFT with ID 1, followNFT properties should be correct', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const timestamp = await getTimestamp(); - - const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - const followNFT = FollowNFT__factory.connect(followNFTAddress, user); - expect(followNFT.address).to.not.eq(ZERO_ADDRESS); - const id = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const name = await followNFT.name(); - const symbol = await followNFT.symbol(); - const owner = await followNFT.ownerOf(id); - const mintTimestamp = await followNFT.mintTimestampOf(id); - const followNFTURI = await followNFT.tokenURI(id); - const tokenData = await followNFT.tokenDataOf(id); - - expect(id).to.eq(1); - expect(name).to.eq(MOCK_PROFILE_HANDLE + '-Follower'); - expect(symbol).to.eq(getAbbreviation(MOCK_PROFILE_HANDLE) + '-Fl'); - expect(owner).to.eq(userTwoAddress); - expect(tokenData.owner).to.eq(userTwoAddress); - expect(tokenData.mintTimestamp).to.eq(timestamp); - expect(followNFTURI).to.eq(MOCK_FOLLOW_NFT_URI); - expect(mintTimestamp).to.eq(timestamp); - }); - - it('UserTwo should follow profile 1 twice, receiving followNFTs with IDs 1 and 2', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - const followNFT = FollowNFT__factory.connect(followNFTAddress, user); - const idOne = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const idTwo = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 1); - expect(idOne).to.eq(1); - expect(idTwo).to.eq(2); - }); - - it('UserTwo should follow profile 1 3 times in the same call, receive IDs 1,2 and 3', async function () { - await expect( - lensHub - .connect(userTwo) - .follow([FIRST_PROFILE_ID, FIRST_PROFILE_ID, FIRST_PROFILE_ID], [[], [], []]) - ).to.not.be.reverted; - const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - const followNFT = FollowNFT__factory.connect(followNFTAddress, user); - const idOne = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 0); - const idTwo = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 1); - const idThree = await followNFT.tokenOfOwnerByIndex(userTwoAddress, 2); - expect(idOne).to.eq(1); - expect(idTwo).to.eq(2); - expect(idThree).to.eq(3); - }); - - it('Should return the expected token IDs when following profiles', async function () { - expectEqualArrays( - await followReturningTokenIds({ - vars: { - profileIds: [FIRST_PROFILE_ID, FIRST_PROFILE_ID], - datas: [[], []], - }, - }), - [1, 2] - ); - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce, - MAX_UINT256 - ); - expectEqualArrays( - await followReturningTokenIds({ - vars: { - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }, - }), - [3] - ); - - expectEqualArrays( - await followReturningTokenIds({ - sender: userTwo, - vars: { - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - }, - }), - [4] - ); - - expectEqualArrays( - await followReturningTokenIds({ - vars: { - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - }, - }), - [5] - ); - }); - }); - }); - - context('Meta-tx', function () { - context('Negatives', function () { - it('TestWallet should fail to follow with sig with signature deadline mismatch', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts([FIRST_PROFILE_ID], [[]], nonce, '0'); - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to follow with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts([FIRST_PROFILE_ID], [[]], nonce, '0'); - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('TestWallet should fail to follow with sig with invalid nonce', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce + 1, - MAX_UINT256 - ); - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to follow a nonexistent profile with sig', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID + 1], - [[]], - nonce, - MAX_UINT256 - ); - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID + 1], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.TOKEN_DOES_NOT_EXIST); - }); - - it('TestWallet should sign attempt to follow with sig, cancel with empty permitForAll, then fail to follow with sig', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(); - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should follow profile 1 with sig, receive a follow NFT with ID 1, follow NFT name and symbol should be correct', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - const followNFT = FollowNFT__factory.connect(followNFTAddress, user); - const id = await followNFT.tokenOfOwnerByIndex(testWallet.address, 0); - expect(id).to.eq(1); - const name = await followNFT.name(); - const symbol = await followNFT.symbol(); - expect(name).to.eq(MOCK_PROFILE_HANDLE + '-Follower'); - expect(symbol).to.eq(getAbbreviation(MOCK_PROFILE_HANDLE) + '-Fl'); - }); - - it('TestWallet should follow profile 1 with sig twice in the same call, receive follow NFTs with IDs 1 and 2', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID, FIRST_PROFILE_ID], - [[], []], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID, FIRST_PROFILE_ID], - datas: [[], []], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - const followNFT = FollowNFT__factory.connect(followNFTAddress, user); - const idOne = await followNFT.tokenOfOwnerByIndex(testWallet.address, 0); - const idTwo = await followNFT.tokenOfOwnerByIndex(testWallet.address, 1); - expect(idOne).to.eq(1); - expect(idTwo).to.eq(2); - const name = await followNFT.name(); - const symbol = await followNFT.symbol(); - expect(name).to.eq(MOCK_PROFILE_HANDLE + '-Follower'); - expect(symbol).to.eq(getAbbreviation(MOCK_PROFILE_HANDLE) + '-Fl'); - }); - }); - }); -}); diff --git a/test/hub/interactions/governance.spec.ts b/test/hub/interactions/governance.spec.ts deleted file mode 100644 index 0ade3ce..0000000 --- a/test/hub/interactions/governance.spec.ts +++ /dev/null @@ -1,55 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ERRORS } from '../../helpers/errors'; -import { governance, lensHub, makeSuiteCleanRoom, userAddress } from '../../__setup.spec'; - -makeSuiteCleanRoom('Governance Functions', function () { - context('Negatives', function () { - it('User should not be able to call governance functions', async function () { - await expect(lensHub.setGovernance(userAddress)).to.be.revertedWith(ERRORS.NOT_GOVERNANCE); - await expect(lensHub.whitelistFollowModule(userAddress, true)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE - ); - await expect(lensHub.whitelistReferenceModule(userAddress, true)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE - ); - await expect(lensHub.whitelistCollectModule(userAddress, true)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE - ); - }); - }); - - context('Scenarios', function () { - it('Governance should successfully whitelist and unwhitelist modules', async function () { - await expect( - lensHub.connect(governance).whitelistFollowModule(userAddress, true) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistReferenceModule(userAddress, true) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(userAddress, true) - ).to.not.be.reverted; - expect(await lensHub.isFollowModuleWhitelisted(userAddress)).to.eq(true); - expect(await lensHub.isReferenceModuleWhitelisted(userAddress)).to.eq(true); - expect(await lensHub.isCollectModuleWhitelisted(userAddress)).to.eq(true); - - await expect( - lensHub.connect(governance).whitelistFollowModule(userAddress, false) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistReferenceModule(userAddress, false) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(userAddress, false) - ).to.not.be.reverted; - expect(await lensHub.isFollowModuleWhitelisted(userAddress)).to.eq(false); - expect(await lensHub.isReferenceModuleWhitelisted(userAddress)).to.eq(false); - expect(await lensHub.isCollectModuleWhitelisted(userAddress)).to.eq(false); - }); - - it('Governance should successfully change the governance address', async function () { - await expect(lensHub.connect(governance).setGovernance(userAddress)).to.not.be.reverted; - }); - }); -}); diff --git a/test/hub/interactions/multi-state-hub.spec.ts b/test/hub/interactions/multi-state-hub.spec.ts deleted file mode 100644 index ef5c4f0..0000000 --- a/test/hub/interactions/multi-state-hub.spec.ts +++ /dev/null @@ -1,1926 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - getCollectWithSigParts, - getCommentWithSigParts, - getFollowWithSigParts, - getMirrorWithSigParts, - getPostWithSigParts, - getSetDispatcherWithSigParts, - getSetFollowModuleWithSigParts, - getSetFollowNFTURIWithSigParts, - getSetProfileImageURIWithSigParts, - ProtocolState, -} from '../../helpers/utils'; -import { - freeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - testWallet, - userAddress, - userTwoAddress, - abiCoder, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Multi-State Hub', function () { - context('Common', function () { - context('Negatives', function () { - it('User should fail to set the state on the hub', async function () { - await expect(lensHub.setState(ProtocolState.Paused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - await expect(lensHub.setState(ProtocolState.Unpaused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - }); - - it('User should fail to set the emergency admin', async function () { - await expect(lensHub.setEmergencyAdmin(userAddress)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE - ); - }); - - it('Governance should set user as emergency admin, user should fail to set protocol state to Unpaused', async function () { - await expect(lensHub.connect(governance).setEmergencyAdmin(userAddress)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.Unpaused)).to.be.revertedWith( - ERRORS.EMERGENCY_ADMIN_CANNOT_UNPAUSE - ); - }); - - it('Governance should set user as emergency admin, user should fail to set protocol state to PublishingPaused or Paused from Paused', async function () { - await expect(lensHub.connect(governance).setEmergencyAdmin(userAddress)).to.not.be.reverted; - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.be.revertedWith( - ERRORS.PAUSED - ); - await expect(lensHub.setState(ProtocolState.Paused)).to.be.revertedWith(ERRORS.PAUSED); - }); - }); - - context('Scenarios', function () { - it('Governance should set user as emergency admin, user sets protocol state but fails to set emergency admin, governance sets emergency admin to the zero address, user fails to set protocol state', async function () { - await expect(lensHub.connect(governance).setEmergencyAdmin(userAddress)).to.not.be.reverted; - - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.Paused)).to.not.be.reverted; - await expect(lensHub.setEmergencyAdmin(ZERO_ADDRESS)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE - ); - - await expect( - lensHub.connect(governance).setEmergencyAdmin(ZERO_ADDRESS) - ).to.not.be.reverted; - - await expect(lensHub.setState(ProtocolState.Paused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - await expect(lensHub.setState(ProtocolState.Unpaused)).to.be.revertedWith( - ERRORS.NOT_GOVERNANCE_OR_EMERGENCY_ADMIN - ); - }); - - it('Governance should set the protocol state, fetched protocol state should be accurate', async function () { - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - expect(await lensHub.getState()).to.eq(ProtocolState.Paused); - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - expect(await lensHub.getState()).to.eq(ProtocolState.PublishingPaused); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - expect(await lensHub.getState()).to.eq(ProtocolState.Unpaused); - }); - - it('Governance should set user as emergency admin, user should set protocol state to PublishingPaused, then Paused, then fail to set it to PublishingPaused', async function () { - await expect(lensHub.connect(governance).setEmergencyAdmin(userAddress)).to.not.be.reverted; - - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.Paused)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.be.revertedWith( - ERRORS.PAUSED - ); - }); - - it('Governance should set user as emergency admin, user should set protocol state to PublishingPaused, then set it to PublishingPaused again without reverting', async function () { - await expect(lensHub.connect(governance).setEmergencyAdmin(userAddress)).to.not.be.reverted; - - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.not.be.reverted; - await expect(lensHub.setState(ProtocolState.PublishingPaused)).to.not.be.reverted; - }); - }); - }); - - context('Paused State', function () { - context('Scenarios', async function () { - it('User should create a profile, governance should pause the hub, transferring the profile should fail', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.transferFrom(userAddress, userTwoAddress, FIRST_PROFILE_ID) - ).to.be.revertedWith(ERRORS.PAUSED); - }); - - it('Governance should pause the hub, profile creation should fail, then governance unpauses the hub and profile creation should work', async function () { - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting follow module should fail, then governance unpauses the hub and setting follow module should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, ZERO_ADDRESS, []) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, ZERO_ADDRESS, []) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting follow module with sig should fail, then governance unpauses the hub and setting follow module with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetFollowModuleWithSigParts( - FIRST_PROFILE_ID, - ZERO_ADDRESS, - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setFollowModuleWithSig({ - profileId: FIRST_PROFILE_ID, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.setFollowModuleWithSig({ - profileId: FIRST_PROFILE_ID, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting dispatcher should fail, then governance unpauses the hub and setting dispatcher should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress)).to.be.revertedWith( - ERRORS.PAUSED - ); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress)).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting dispatcher with sig should fail, then governance unpauses the hub and setting dispatcher with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getSetDispatcherWithSigParts( - FIRST_PROFILE_ID, - userTwoAddress, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setDispatcherWithSig({ - profileId: FIRST_PROFILE_ID, - dispatcher: userTwoAddress, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.setDispatcherWithSig({ - profileId: FIRST_PROFILE_ID, - dispatcher: userTwoAddress, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting profile URI should fail, then governance unpauses the hub and setting profile URI should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, MOCK_URI)).to.be.revertedWith( - ERRORS.PAUSED - ); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, MOCK_URI)).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting profile URI with sig should fail, then governance unpauses the hub and setting profile URI should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getSetProfileImageURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setProfileImageURIWithSig({ - profileId: FIRST_PROFILE_ID, - imageURI: MOCK_URI, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.setProfileImageURIWithSig({ - profileId: FIRST_PROFILE_ID, - imageURI: MOCK_URI, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting follow NFT URI should fail, then governance unpauses the hub and setting follow NFT URI should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.setFollowNFTURI(FIRST_PROFILE_ID, MOCK_URI)).to.be.revertedWith( - ERRORS.PAUSED - ); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.setFollowNFTURI(FIRST_PROFILE_ID, MOCK_URI)).to.not.be.reverted; - }); - - it('Governance should pause the hub, setting follow NFT URI with sig should fail, then governance unpauses the hub and setting follow NFT URI should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getSetFollowNFTURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setFollowNFTURIWithSig({ - profileId: FIRST_PROFILE_ID, - followNFTURI: MOCK_URI, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.setFollowNFTURIWithSig({ - profileId: FIRST_PROFILE_ID, - followNFTURI: MOCK_URI, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, posting should fail, then governance unpauses the hub and posting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, posting with sig should fail, then governance unpauses the hub and posting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, commenting should fail, then governance unpauses the hub and commenting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, commenting with sig should fail, then governance unpauses the hub and commenting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, mirroring should fail, then governance unpauses the hub and mirroring should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, mirroring with sig should fail, then governance unpauses the hub and mirroring with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, burning should fail, then governance unpauses the hub and burning should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.burn(FIRST_PROFILE_ID)).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.burn(FIRST_PROFILE_ID)).to.not.be.reverted; - }); - - it('Governance should pause the hub, following should fail, then governance unpauses the hub and following should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - }); - - it('Governance should pause the hub, following with sig should fail, then governance unpauses the hub and following with sig should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause the hub, collecting should fail, then governance unpauses the hub and collecting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('Governance should pause the hub, collecting with sig should fail, then governance unpauses the hub and collecting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - - await expect(lensHub.connect(governance).setState(ProtocolState.Paused)).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - }); - }); - - context('PublishingPaused State', function () { - context('Scenarios', async function () { - it('Governance should pause publishing, profile creation should work', async function () { - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting follow module should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, ZERO_ADDRESS, []) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting follow module with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetFollowModuleWithSigParts( - FIRST_PROFILE_ID, - ZERO_ADDRESS, - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setFollowModuleWithSig({ - profileId: FIRST_PROFILE_ID, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting dispatcher should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect(lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress)).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting dispatcher with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getSetDispatcherWithSigParts( - FIRST_PROFILE_ID, - userTwoAddress, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setDispatcherWithSig({ - profileId: FIRST_PROFILE_ID, - dispatcher: userTwoAddress, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting profile URI should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, MOCK_URI)).to.not.be.reverted; - }); - - it('Governance should pause publishing, setting profile URI with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const { v, r, s } = await getSetProfileImageURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.setProfileImageURIWithSig({ - profileId: FIRST_PROFILE_ID, - imageURI: MOCK_URI, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, posting should fail, then governance unpauses the hub and posting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, posting with sig should fail, then governance unpauses the hub and posting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, commenting should fail, then governance unpauses the hub and commenting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, commenting with sig should fail, then governance unpauses the hub and commenting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, mirroring should fail, then governance unpauses the hub and mirroring should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, mirroring with sig should fail, then governance unpauses the hub and mirroring with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLISHING_PAUSED); - - await expect( - lensHub.connect(governance).setState(ProtocolState.Unpaused) - ).to.not.be.reverted; - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, burning should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect(lensHub.burn(FIRST_PROFILE_ID)).to.not.be.reverted; - }); - - it('Governance should pause publishing, following should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - }); - - it('Governance should pause publishing, following with sig should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getFollowWithSigParts( - [FIRST_PROFILE_ID], - [[]], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.followWithSig({ - follower: testWallet.address, - profileIds: [FIRST_PROFILE_ID], - datas: [[]], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - - it('Governance should pause publishing, collecting should work', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('Governance should pause publishing, collecting with sig should work', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getCollectWithSigParts( - FIRST_PROFILE_ID, - '1', - [], - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.collectWithSig({ - collector: testWallet.address, - profileId: FIRST_PROFILE_ID, - pubId: '1', - data: [], - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - }); - }); - }); -}); diff --git a/test/hub/interactions/publishing-comments.spec.ts b/test/hub/interactions/publishing-comments.spec.ts deleted file mode 100644 index b8d671d..0000000 --- a/test/hub/interactions/publishing-comments.spec.ts +++ /dev/null @@ -1,781 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - cancelWithPermitForAll, - commentReturningTokenId, - getCommentWithSigParts, -} from '../../helpers/utils'; -import { - abiCoder, - freeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - mockReferenceModule, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - OTHER_MOCK_URI, - testWallet, - timedFeeCollectModule, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Publishing Comments', function () { - context('Generic', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(timedFeeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistReferenceModule(mockReferenceModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('UserTwo should fail to publish a comment to a profile owned by User', async function () { - await expect( - lensHub.connect(userTwo).comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: ZERO_ADDRESS, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); - }); - - it('User should fail to comment with an unwhitelisted collect module', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: ZERO_ADDRESS, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.COLLECT_MODULE_NOT_WHITELISTED); - }); - - it('User should fail to comment with an unwhitelisted reference module', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: userAddress, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('User should fail to comment with invalid collect module data format', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: [0x2, 0x12, 0x20], - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.NO_REASON_ABI_DECODE); - }); - - it('User should fail to comment with invalid reference module data format', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: mockReferenceModule.address, - referenceModuleInitData: [0x12, 0x23], - }) - ).to.be.revertedWith(ERRORS.NO_REASON_ABI_DECODE); - }); - - it('User should fail to comment on a publication that does not exist', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 3, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLICATION_DOES_NOT_EXIST); - }); - - it('User should fail to comment on the same comment they are creating (pubId = 2, commentCeption)', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.CANNOT_COMMENT_ON_SELF); - }); - }); - - context('Scenarios', function () { - it('User should create a comment with empty collect module data, reference module, and reference module data, fetched comment data should be accurate', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 2); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(MOCK_URI); - expect(pub.collectModule).to.eq(freeCollectModule.address); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - - it('Should return the expected token IDs when commenting publications', async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: 'testwallet', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(testWallet).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID + 1, - OTHER_MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - expect( - await commentReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID + 1, - contentURI: OTHER_MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }, - }) - ).to.eq(1); - - expect( - await commentReturningTokenId({ - sender: userTwo, - vars: { - profileId: FIRST_PROFILE_ID + 2, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - }, - }) - ).to.eq(1); - - expect( - await commentReturningTokenId({ - sender: testWallet, - vars: { - profileId: FIRST_PROFILE_ID + 1, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - }, - }) - ).to.eq(2); - - expect( - await commentReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - }, - }) - ).to.eq(2); - }); - - it('User should create a post using the mock reference module as reference module, then comment on that post', async function () { - const data = abiCoder.encode(['uint256'], ['1']); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: mockReferenceModule.address, - referenceModuleInitData: data, - }) - ).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - }); - }); - - context('Meta-tx', function () { - beforeEach(async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('Testwallet should fail to comment with sig with signature deadline mismatch', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to comment with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('Testwallet should fail to comment with sig with invalid nonce', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce + 1, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to comment with sig with unwhitelisted collect module', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - userAddress, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: userAddress, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.COLLECT_MODULE_NOT_WHITELISTED); - }); - - it('TestWallet should fail to comment with sig with unwhitelisted reference module', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - mockReferenceModule.address, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: mockReferenceModule.address, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('TestWallet should fail to comment with sig on a publication that does not exist', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - OTHER_MOCK_URI, - FIRST_PROFILE_ID, - '3', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: OTHER_MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '3', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLICATION_DOES_NOT_EXIST); - }); - - it('TestWallet should fail to comment with sig on the comment they are creating (commentCeption)', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - OTHER_MOCK_URI, - FIRST_PROFILE_ID, - '2', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: OTHER_MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '2', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.CANNOT_COMMENT_ON_SELF); - }); - - it('TestWallet should sign attempt to comment with sig, cancel via empty permitForAll, then fail to comment with sig', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - OTHER_MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: OTHER_MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should comment with sig, fetched comment data should be accurate', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getCommentWithSigParts( - FIRST_PROFILE_ID, - OTHER_MOCK_URI, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.commentWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: OTHER_MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: referenceModuleData, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 2); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(OTHER_MOCK_URI); - expect(pub.collectModule).to.eq(freeCollectModule.address); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - }); - }); -}); diff --git a/test/hub/interactions/publishing-mirrors.spec.ts b/test/hub/interactions/publishing-mirrors.spec.ts deleted file mode 100644 index 294a778..0000000 --- a/test/hub/interactions/publishing-mirrors.spec.ts +++ /dev/null @@ -1,626 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - cancelWithPermitForAll, - getMirrorWithSigParts, - mirrorReturningTokenId, -} from '../../helpers/utils'; -import { - abiCoder, - freeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - mockReferenceModule, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - testWallet, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Publishing mirrors', function () { - context('Generic', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistReferenceModule(mockReferenceModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('UserTwo should fail to publish a mirror to a profile owned by User', async function () { - await expect( - lensHub.connect(userTwo).mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); - }); - - it('User should fail to mirror with an unwhitelisted reference module', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: userAddress, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('User should fail to mirror with invalid reference module data format', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: mockReferenceModule.address, - referenceModuleInitData: [0x12, 0x23], - }) - ).to.be.revertedWith(ERRORS.NO_REASON_ABI_DECODE); - }); - - it('User should fail to mirror a publication that does not exist', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.PUBLICATION_DOES_NOT_EXIST); - }); - }); - - context('Scenarios', function () { - it('Should return the expected token IDs when mirroring publications', async function () { - await expect( - lensHub.createProfile({ - to: testWallet.address, - handle: 'testwallet', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - expect( - await mirrorReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(2); - - expect( - await mirrorReturningTokenId({ - sender: userTwo, - vars: { - profileId: FIRST_PROFILE_ID + 2, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(1); - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID + 1, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - expect( - await mirrorReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID + 1, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }, - }) - ).to.eq(1); - - expect( - await mirrorReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID + 1, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(3); - }); - - it('User should create a mirror with empty reference module and reference module data, fetched mirror data should be accurate', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 2); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(''); - expect(pub.collectModule).to.eq(ZERO_ADDRESS); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - - it('User should mirror a mirror with empty reference module and reference module data, fetched mirror data should be accurate and point to the original post', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 3); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(''); - expect(pub.collectModule).to.eq(ZERO_ADDRESS); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - - it('User should create a post using the mock reference module as reference module, then mirror that post', async function () { - const data = abiCoder.encode(['uint256'], ['1']); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: mockReferenceModule.address, - referenceModuleInitData: data, - }) - ).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 2, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - }); - }); - - context('Meta-tx', function () { - beforeEach(async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(testWallet).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('Testwallet should fail to mirror with sig with signature deadline mismatch', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to mirror with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('Testwallet should fail to mirror with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce + 1, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to mirror with sig with unwhitelisted reference module', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - userAddress, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: userAddress, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('TestWallet should fail to mirror a publication with sig that does not exist yet', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '2', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '2', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.PUBLICATION_DOES_NOT_EXIST); - }); - - it('TestWallet should sign attempt to mirror with sig, cancel via empty permitForAll, then fail to mirror with sig', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('Testwallet should mirror with sig, fetched mirror data should be accurate', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '1', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '1', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 2); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(''); - expect(pub.collectModule).to.eq(ZERO_ADDRESS); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - - it('TestWallet should mirror a mirror with sig, fetched mirror data should be accurate', async function () { - await expect( - lensHub.connect(testWallet).mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const referenceModuleInitData = []; - const referenceModuleData = []; - - const { v, r, s } = await getMirrorWithSigParts( - FIRST_PROFILE_ID, - FIRST_PROFILE_ID, - '2', - referenceModuleData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.mirrorWithSig({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: '2', - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 3); - expect(pub.profileIdPointed).to.eq(FIRST_PROFILE_ID); - expect(pub.pubIdPointed).to.eq(1); - expect(pub.contentURI).to.eq(''); - expect(pub.collectModule).to.eq(ZERO_ADDRESS); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - }); - }); -}); diff --git a/test/hub/interactions/publishing-posts.spec.ts b/test/hub/interactions/publishing-posts.spec.ts deleted file mode 100644 index bdb748a..0000000 --- a/test/hub/interactions/publishing-posts.spec.ts +++ /dev/null @@ -1,566 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - cancelWithPermitForAll, - getPostWithSigParts, - postReturningTokenId, -} from '../../helpers/utils'; -import { - freeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - mockModuleData, - mockReferenceModule, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - testWallet, - timedFeeCollectModule, - userAddress, - userTwo, - abiCoder, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Publishing Posts', function () { - context('Generic', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('UserTwo should fail to post to a profile owned by User', async function () { - await expect( - lensHub.connect(userTwo).post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); - }); - - it('User should fail to post with an unwhitelisted collect module', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.COLLECT_MODULE_NOT_WHITELISTED); - }); - - it('User should fail to post with an unwhitelisted reference module', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: userAddress, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('User should fail to post with invalid collect module data format', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(timedFeeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: [0x12, 0x34], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.NO_REASON_ABI_DECODE); - }); - - it('User should fail to post with invalid reference module data format', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.connect(governance).whitelistReferenceModule(mockReferenceModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: mockReferenceModule.address, - referenceModuleInitData: [0x12, 0x23], - }) - ).to.be.revertedWith(ERRORS.NO_REASON_ABI_DECODE); - }); - }); - - context('Scenarios', function () { - it('Should return the expected token IDs when mirroring publications', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.createProfile({ - to: testWallet.address, - handle: 'testwallet', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - expect( - await postReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(1); - - expect( - await postReturningTokenId({ - sender: userTwo, - vars: { - profileId: FIRST_PROFILE_ID + 2, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(1); - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID + 1, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - expect( - await postReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID + 1, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }, - }) - ).to.eq(1); - - expect( - await postReturningTokenId({ - vars: { - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }, - }) - ).to.eq(2); - }); - - it('User should create a post with empty collect and reference module data, fetched post data should be accurate', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 1); - expect(pub.profileIdPointed).to.eq(0); - expect(pub.pubIdPointed).to.eq(0); - expect(pub.contentURI).to.eq(MOCK_URI); - expect(pub.collectModule).to.eq(freeCollectModule.address); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - - it('User should create a post with a whitelisted collect and reference module', async function () { - await expect( - lensHub.connect(governance).whitelistReferenceModule(mockReferenceModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: mockReferenceModule.address, - referenceModuleInitData: mockModuleData, - }) - ).to.not.be.reverted; - }); - }); - }); - - context('Meta-tx', function () { - beforeEach(async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('Testwallet should fail to post with sig with signature deadline mismatch', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to post with sig with invalid deadline', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - '0' - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('Testwallet should fail to post with sig with invalid nonce', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - ZERO_ADDRESS, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce + 1, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: ZERO_ADDRESS, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('Testwallet should fail to post with sig with an unwhitelisted collect module', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = []; - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - userAddress, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: userAddress, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.COLLECT_MODULE_NOT_WHITELISTED); - }); - - it('Testwallet should fail to post with sig with an unwhitelisted reference module', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - userAddress, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: userAddress, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.REFERENCE_MODULE_NOT_WHITELISTED); - }); - - it('TestWallet should sign attempt to post with sig, cancel via empty permitForAll, then fail to post with sig', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should post with sig, fetched post data should be accurate', async function () { - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - const collectModuleInitData = abiCoder.encode(['bool'], [true]); - const referenceModuleInitData = []; - const referenceModuleData = []; - const { v, r, s } = await getPostWithSigParts( - FIRST_PROFILE_ID, - MOCK_URI, - freeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - referenceModuleInitData, - nonce, - MAX_UINT256 - ); - - await expect( - lensHub.postWithSig({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: referenceModuleInitData, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.not.be.reverted; - - const pub = await lensHub.getPub(FIRST_PROFILE_ID, 1); - expect(pub.profileIdPointed).to.eq(0); - expect(pub.pubIdPointed).to.eq(0); - expect(pub.contentURI).to.eq(MOCK_URI); - expect(pub.collectModule).to.eq(freeCollectModule.address); - expect(pub.collectNFT).to.eq(ZERO_ADDRESS); - expect(pub.referenceModule).to.eq(ZERO_ADDRESS); - }); - }); - }); -}); diff --git a/test/hub/profiles/default-profile.spec.ts b/test/hub/profiles/default-profile.spec.ts index 317c565..a76c8df 100644 --- a/test/hub/profiles/default-profile.spec.ts +++ b/test/hub/profiles/default-profile.spec.ts @@ -34,28 +34,28 @@ makeSuiteCleanRoom('Default profile Functionality', function () { context('Negatives', function () { it('UserTwo should fail to set the default profile as a profile owned by user 1', async function () { await expect( - lensHub.connect(userTwo).setDefaultProfile(FIRST_PROFILE_ID) + lensHub.connect(userTwo).setDefaultProfile(userTwoAddress, FIRST_PROFILE_ID) ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); }); }); context('Scenarios', function () { it('User should set the default profile', async function () { - await expect(lensHub.setDefaultProfile(FIRST_PROFILE_ID)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); + await expect(lensHub.setDefaultProfile(userAddress, FIRST_PROFILE_ID)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); }); it('User should set the default profile and then be able to unset it', async function () { - await expect(lensHub.setDefaultProfile(FIRST_PROFILE_ID)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); + await expect(lensHub.setDefaultProfile(userAddress, FIRST_PROFILE_ID)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); - await expect(lensHub.setDefaultProfile(0)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(0); + await expect(lensHub.setDefaultProfile(userAddress, 0)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(0); }); it('User should set the default profile and then be able to change it to another', async function () { - await expect(lensHub.setDefaultProfile(FIRST_PROFILE_ID)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); + await expect(lensHub.setDefaultProfile(userAddress, FIRST_PROFILE_ID)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); await expect( lensHub.createProfile({ @@ -68,18 +68,18 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - await expect(lensHub.setDefaultProfile(2)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(2); + await expect(lensHub.setDefaultProfile(userAddress, 2)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(2); }); it('User should set the default profile and then transfer it, their default profile should be unset', async function () { - await expect(lensHub.setDefaultProfile(FIRST_PROFILE_ID)).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); + await expect(lensHub.setDefaultProfile(userAddress, FIRST_PROFILE_ID)).to.not.be.reverted; + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(FIRST_PROFILE_ID); await expect( lensHub.transferFrom(userAddress, userTwoAddress, FIRST_PROFILE_ID) ).to.not.be.reverted; - expect(await lensHub.defaultProfile(userAddress)).to.eq(0); + expect(await lensHub.getDefaultProfile(userAddress)).to.eq(0); }); }); }); @@ -110,6 +110,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -133,6 +134,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -156,6 +158,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -181,6 +184,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -204,10 +208,11 @@ makeSuiteCleanRoom('Default profile Functionality', function () { MAX_UINT256 ); - const defaultProfileBeforeUse = await lensHub.defaultProfile(testWallet.address); + const defaultProfileBeforeUse = await lensHub.getDefaultProfile(testWallet.address); await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -219,7 +224,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - const defaultProfileAfter = await lensHub.defaultProfile(testWallet.address); + const defaultProfileAfter = await lensHub.getDefaultProfile(testWallet.address); expect(defaultProfileBeforeUse).to.eq(0); expect(defaultProfileAfter).to.eq(FIRST_PROFILE_ID); @@ -234,10 +239,11 @@ makeSuiteCleanRoom('Default profile Functionality', function () { MAX_UINT256 ); - const defaultProfileBeforeUse = await lensHub.defaultProfile(testWallet.address); + const defaultProfileBeforeUse = await lensHub.getDefaultProfile(testWallet.address); await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, wallet: testWallet.address, profileId: FIRST_PROFILE_ID, sig: { @@ -249,7 +255,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - const defaultProfileAfter = await lensHub.defaultProfile(testWallet.address); + const defaultProfileAfter = await lensHub.getDefaultProfile(testWallet.address); expect(defaultProfileBeforeUse).to.eq(0); expect(defaultProfileAfter).to.eq(FIRST_PROFILE_ID); @@ -262,10 +268,11 @@ makeSuiteCleanRoom('Default profile Functionality', function () { MAX_UINT256 ); - const defaultProfileBeforeUse2 = await lensHub.defaultProfile(testWallet.address); + const defaultProfileBeforeUse2 = await lensHub.getDefaultProfile(testWallet.address); await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, wallet: testWallet.address, profileId: 0, sig: { @@ -277,7 +284,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - const defaultProfileAfter2 = await lensHub.defaultProfile(testWallet.address); + const defaultProfileAfter2 = await lensHub.getDefaultProfile(testWallet.address); expect(defaultProfileBeforeUse2).to.eq(FIRST_PROFILE_ID); expect(defaultProfileAfter2).to.eq(0); @@ -292,10 +299,11 @@ makeSuiteCleanRoom('Default profile Functionality', function () { MAX_UINT256 ); - const defaultProfileBeforeUse = await lensHub.defaultProfile(testWallet.address); + const defaultProfileBeforeUse = await lensHub.getDefaultProfile(testWallet.address); await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, wallet: testWallet.address, sig: { @@ -307,7 +315,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - const defaultProfileAfter = await lensHub.defaultProfile(testWallet.address); + const defaultProfileAfter = await lensHub.getDefaultProfile(testWallet.address); expect(defaultProfileBeforeUse).to.eq(0); expect(defaultProfileAfter).to.eq(FIRST_PROFILE_ID); @@ -331,10 +339,11 @@ makeSuiteCleanRoom('Default profile Functionality', function () { MAX_UINT256 ); - const defaultProfileBeforeUse2 = await lensHub.defaultProfile(testWallet.address); + const defaultProfileBeforeUse2 = await lensHub.getDefaultProfile(testWallet.address); await expect( lensHub.setDefaultProfileWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: 2, wallet: testWallet.address, sig: { @@ -346,7 +355,7 @@ makeSuiteCleanRoom('Default profile Functionality', function () { }) ).to.not.be.reverted; - const defaultProfileAfter2 = await lensHub.defaultProfile(testWallet.address); + const defaultProfileAfter2 = await lensHub.getDefaultProfile(testWallet.address); expect(defaultProfileBeforeUse2).to.eq(1); expect(defaultProfileAfter2).to.eq(2); diff --git a/test/hub/profiles/dispatcher.spec.ts b/test/hub/profiles/dispatcher.spec.ts index f8f669b..8e7906e 100644 --- a/test/hub/profiles/dispatcher.spec.ts +++ b/test/hub/profiles/dispatcher.spec.ts @@ -55,15 +55,16 @@ makeSuiteCleanRoom('Dispatcher Functionality', function () { referenceModule: ZERO_ADDRESS, referenceModuleInitData: [], }) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); + ).to.be.revertedWith(ERRORS.EXECUTOR_INVALID); }); - it("User should set userTwo as dispatcher, userTwo should fail to set follow module on user's profile", async function () { - await expect(lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress)).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).setFollowModule(FIRST_PROFILE_ID, ZERO_ADDRESS, []) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); - }); + // Note: Dispatcher can now do this. + // it("User should set userTwo as dispatcher, userTwo should fail to set follow module on user's profile", async function () { + // await expect(lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress)).to.not.be.reverted; + // await expect( + // lensHub.connect(userTwo).setFollowModule(FIRST_PROFILE_ID, ZERO_ADDRESS, []) + // ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); + // }); }); context('Scenarios', function () { diff --git a/test/hub/profiles/profile-creation.spec.ts b/test/hub/profiles/profile-creation.spec.ts index 96a1b8d..fd6aa6d 100644 --- a/test/hub/profiles/profile-creation.spec.ts +++ b/test/hub/profiles/profile-creation.spec.ts @@ -24,7 +24,7 @@ import { makeSuiteCleanRoom('Profile Creation', function () { context('Generic', function () { context('Negatives', function () { - it('User should fail to create a profile with a handle longer than 31 bytes', async function () { + it.skip('User should fail to create a profile with a handle longer than 31 bytes', async function () { const val = '11111111111111111111111111111111'; expect(val.length).to.eq(32); await expect( @@ -39,7 +39,7 @@ makeSuiteCleanRoom('Profile Creation', function () { ).to.be.revertedWith(ERRORS.INVALID_HANDLE_LENGTH); }); - it('User should fail to create a profile with an empty handle (0 length bytes)', async function () { + it.skip('User should fail to create a profile with an empty handle (0 length bytes)', async function () { await expect( lensHub.createProfile({ to: userAddress, @@ -52,7 +52,7 @@ makeSuiteCleanRoom('Profile Creation', function () { ).to.be.revertedWith(ERRORS.INVALID_HANDLE_LENGTH); }); - it('User should fail to create a profile with a handle with a capital letter', async function () { + it.skip('User should fail to create a profile with a handle with a capital letter', async function () { await expect( lensHub.createProfile({ to: userAddress, @@ -65,7 +65,7 @@ makeSuiteCleanRoom('Profile Creation', function () { ).to.be.revertedWith(ERRORS.HANDLE_CONTAINS_INVALID_CHARACTERS); }); - it('User should fail to create a profile with a handle with an invalid character', async function () { + it.skip('User should fail to create a profile with a handle with an invalid character', async function () { await expect( lensHub.createProfile({ to: userAddress, @@ -143,7 +143,7 @@ makeSuiteCleanRoom('Profile Creation', function () { }); context('Scenarios', function () { - it('User should be able to create a profile with a handle, receive an NFT and the handle should resolve to the NFT ID, userTwo should do the same', async function () { + it.skip('User should be able to create a profile with a handle, receive an NFT and the handle should resolve to the NFT ID, userTwo should do the same', async function () { let timestamp: any; let owner: string; let totalSupply: BigNumber; @@ -212,7 +212,7 @@ makeSuiteCleanRoom('Profile Creation', function () { await createProfileReturningTokenId({ vars: { to: userAddress, - handle: 'token.id_1', + // handle: 'token.id_1', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -227,7 +227,7 @@ makeSuiteCleanRoom('Profile Creation', function () { sender: userTwo, vars: { to: userTwoAddress, - handle: 'token.id_2', + // handle: 'token.id_2', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -241,7 +241,7 @@ makeSuiteCleanRoom('Profile Creation', function () { await createProfileReturningTokenId({ vars: { to: userAddress, - handle: 'token.id_3', + // handle: 'token.id_3', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -255,7 +255,7 @@ makeSuiteCleanRoom('Profile Creation', function () { await expect( lensHub.createProfile({ to: userAddress, - handle: 'morse--__-_--code', + // handle: 'morse--__-_--code', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -264,11 +264,11 @@ makeSuiteCleanRoom('Profile Creation', function () { ).to.not.be.reverted; }); - it('User should be able to create a profile with a handle 16 bytes long, then fail to create with the same handle, and create again with a different handle', async function () { + it.skip('User should be able to create a profile with a handle 16 bytes long, then fail to create with the same handle, and create again with a different handle', async function () { await expect( lensHub.createProfile({ to: userAddress, - handle: '123456789012345', + // handle: '123456789012345', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -278,7 +278,7 @@ makeSuiteCleanRoom('Profile Creation', function () { await expect( lensHub.createProfile({ to: userAddress, - handle: '123456789012345', + // handle: '123456789012345', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], @@ -288,7 +288,7 @@ makeSuiteCleanRoom('Profile Creation', function () { await expect( lensHub.createProfile({ to: userAddress, - handle: 'abcdefghijklmno', + // handle: 'abcdefghijklmno', imageURI: MOCK_PROFILE_URI, followModule: ZERO_ADDRESS, followModuleInitData: [], diff --git a/test/hub/profiles/profile-uri.spec.ts b/test/hub/profiles/profile-uri.spec.ts index 994c8d9..ec0e2c5 100644 --- a/test/hub/profiles/profile-uri.spec.ts +++ b/test/hub/profiles/profile-uri.spec.ts @@ -48,7 +48,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { it('UserTwo should fail to set the profile URI on profile owned by user 1', async function () { await expect( lensHub.connect(userTwo).setProfileImageURI(FIRST_PROFILE_ID, MOCK_URI) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); + ).to.be.revertedWith(ERRORS.EXECUTOR_INVALID); }); it('UserTwo should fail to set the profile URI on profile owned by user 1', async function () { @@ -62,12 +62,12 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { it('UserTwo should fail to change the follow NFT URI for profile one', async function () { await expect( lensHub.connect(userTwo).setFollowNFTURI(FIRST_PROFILE_ID, OTHER_MOCK_URI) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); + ).to.be.revertedWith(ERRORS.EXECUTOR_INVALID); }); }); - context('Scenarios', function () { - it('User should have a custom picture tokenURI after setting the profile imageURI', async function () { + context.skip('Scenarios', function () { + it('User should have a custom image tokenURI after setting the profile imageURI', async function () { await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, MOCK_URI)).to.not.be.reverted; const tokenUri = await lensHub.tokenURI(FIRST_PROFILE_ID); const metadata = await getMetadataFromBase64TokenUri(tokenUri); @@ -85,6 +85,13 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { expect(actualSvg).to.eq(expectedSvg); }); + it('User should set a custom image URI under 32 bytes of length, profile image URI should be accurate', async function () { + const testURI = 'mockuri'; + await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, testURI)).to.not.be.reverted; + const profileImageURI = (await lensHub.getProfile(FIRST_PROFILE_ID)).imageURI; + expect(profileImageURI).to.eq(testURI); + }); + it('Default image should be used when no imageURI set', async function () { await expect(lensHub.setProfileImageURI(FIRST_PROFILE_ID, '')).to.not.be.reverted; const tokenUri = await lensHub.tokenURI(FIRST_PROFILE_ID); @@ -178,7 +185,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { ); expect(svgBeforeFollow).to.eq(expectedSvg); - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; const tokenUriAfterFollow = await lensHub.tokenURI(FIRST_PROFILE_ID); const metadataAfterFollow = await getMetadataFromBase64TokenUri(tokenUriAfterFollow); @@ -217,7 +224,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { }); it('User should follow profile 1, user should change the follow NFT URI, URI is accurate before and after the change', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; const followNFTAddress = await lensHub.getFollowNFT(FIRST_PROFILE_ID); const followNFT = FollowNFT__factory.connect(followNFTAddress, user); @@ -258,6 +265,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setProfileImageURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, imageURI: MOCK_URI, sig: { @@ -281,6 +289,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setProfileImageURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, imageURI: MOCK_URI, sig: { @@ -304,6 +313,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setProfileImageURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, imageURI: MOCK_URI, sig: { @@ -329,6 +339,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setProfileImageURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, imageURI: MOCK_URI, sig: { @@ -352,6 +363,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setFollowNFTURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followNFTURI: MOCK_URI, sig: { @@ -375,6 +387,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setFollowNFTURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followNFTURI: MOCK_URI, sig: { @@ -398,6 +411,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setFollowNFTURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followNFTURI: MOCK_URI, sig: { @@ -423,6 +437,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setFollowNFTURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followNFTURI: MOCK_URI, sig: { @@ -437,7 +452,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { }); context('Scenarios', function () { - it('TestWallet should set the profile URI with sig', async function () { + it.skip('TestWallet should set the profile URI with sig', async function () { const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); const { v, r, s } = await getSetProfileImageURIWithSigParts( FIRST_PROFILE_ID, @@ -465,6 +480,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setProfileImageURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, imageURI: MOCK_URI, sig: { @@ -509,6 +525,7 @@ makeSuiteCleanRoom('Profile URI Functionality', function () { await expect( lensHub.setFollowNFTURIWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followNFTURI: MOCK_URI, sig: { diff --git a/test/hub/profiles/setting-follow-module.spec.ts b/test/hub/profiles/setting-follow-module.spec.ts index fdf780f..d0b14a4 100644 --- a/test/hub/profiles/setting-follow-module.spec.ts +++ b/test/hub/profiles/setting-follow-module.spec.ts @@ -37,7 +37,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { it('UserTwo should fail to set the follow module for the profile owned by User', async function () { await expect( lensHub.connect(userTwo).setFollowModule(FIRST_PROFILE_ID, userAddress, []) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); + ).to.be.revertedWith(ERRORS.EXECUTOR_INVALID); }); it('User should fail to set a follow module that is not whitelisted', async function () { @@ -109,6 +109,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: followModuleInitData, @@ -140,6 +141,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: followModuleInitData, @@ -171,6 +173,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: followModuleInitData, @@ -198,6 +201,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: followModuleInitData, @@ -230,6 +234,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: mockModuleData, @@ -262,6 +267,7 @@ makeSuiteCleanRoom('Setting Follow Module', function () { await expect( lensHub.setFollowModuleWithSig({ + delegatedSigner: ZERO_ADDRESS, profileId: FIRST_PROFILE_ID, followModule: mockFollowModule.address, followModuleInitData: mockModuleData, diff --git a/test/modules/collect/fee-collect-module.spec.ts b/test/modules/collect/fee-collect-module.spec.ts deleted file mode 100644 index e00a5ca..0000000 --- a/test/modules/collect/fee-collect-module.spec.ts +++ /dev/null @@ -1,700 +0,0 @@ -import { BigNumber } from '@ethersproject/contracts/node_modules/@ethersproject/bignumber'; -import { parseEther } from '@ethersproject/units'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ERC20__factory } from '../../../typechain-types'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - BPS_MAX, - currency, - feeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - lensHubImpl, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - moduleGlobals, - REFERRAL_FEE_BPS, - treasuryAddress, - TREASURY_FEE_BPS, - user, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Fee Collect Module', function () { - const DEFAULT_COLLECT_PRICE = parseEther('10'); - - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(feeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Publication Creation', function () { - it('user should fail to post with fee collect module using unwhitelisted currency', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, userTwoAddress, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with fee collect module using zero recipient', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, ZERO_ADDRESS, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with fee collect module using referral fee greater than max BPS', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, 10001, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with fee collect module using zero amount', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [0, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - }); - - context('Collecting', function () { - beforeEach(async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process collect without being the hub', async function () { - await expect( - feeCollectModule - .connect(userTwo) - .processCollect(0, userTwoAddress, FIRST_PROFILE_ID, 1, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Governance should set the treasury fee BPS to zero, userTwo collecting should not emit a transfer event to the treasury', async function () { - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(1); - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, DEFAULT_COLLECT_PRICE], - currency, - currency.address - ); - }); - - it('UserTwo should mirror the original post, governance should set the treasury fee BPS to zero, userTwo collecting their mirror should not emit a transfer event to the treasury', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(secondProfileId, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(2); - - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const amount = DEFAULT_COLLECT_PRICE.sub(expectedReferralAmount); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, amount], - currency, - currency.address - ); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userTwoAddress, expectedReferralAmount], - currency, - currency.address - ); - }); - - it('UserTwo should fail to collect without following', async function () { - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('UserTwo should fail to collect passing a different expected price in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect passing a different expected currency in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect without first approving module with currency', async function () { - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.ERC20_INSUFFICIENT_ALLOWANCE); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const data = abiCoder.encode(['uint256'], [DEFAULT_COLLECT_PRICE]); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected price in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected currency in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - }); - }); - - context('Scenarios', function () { - it('User should post with fee collect module as the collect module and data, correct events should be emitted', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - const tx = lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 1, - MOCK_URI, - feeCollectModule.address, - [collectModuleInitData], - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('User should post with the fee collect module as the collect module and data, fetched publication data should be accurate', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - const postTimestamp = await getTimestamp(); - - const fetchedData = await feeCollectModule.getPublicationData(FIRST_PROFILE_ID, 1); - expect(fetchedData.amount).to.eq(DEFAULT_COLLECT_PRICE); - expect(fetchedData.recipient).to.eq(userAddress); - expect(fetchedData.currency).to.eq(currency.address); - expect(fetchedData.referralFee).to.eq(REFERRAL_FEE_BPS); - expect(fetchedData.followerOnly).to.eq(true); - }); - - it('User should post with the fee collect module as the collect module and data, allowing non-followers to collect, user two collects without following, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, false] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with the fee collect module as the collect module and data, user two follows, then collects and pays fee, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with the fee collect module as the collect module and data, user two follows, then collects twice, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(BigNumber.from(DEFAULT_COLLECT_PRICE).mul(2)) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount.mul(2)); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount.mul(2)); - }); - - it('User should post with the fee collect module as the collect module and data, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const expectedReferrerAmount = BigNumber.from(MAX_UINT256) - .sub(DEFAULT_COLLECT_PRICE) - .add(expectedReferralAmount); - const expectedRecipientAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .sub(expectedReferralAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq(expectedReferrerAmount); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with the fee collect module as the collect module and data, with no referral fee, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, 0, true] - ); - - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - }); -}); diff --git a/test/modules/collect/free-collect-module.spec.ts b/test/modules/collect/free-collect-module.spec.ts deleted file mode 100644 index 6bd22ed..0000000 --- a/test/modules/collect/free-collect-module.spec.ts +++ /dev/null @@ -1,189 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - approvalFollowModule, - freeCollectModule, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - user, - userAddress, - userTwo, - userTwoAddress, - abiCoder, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Free Collect Module', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Collecting', function () { - it('UserTwo should fail to collect without following without any follow module set', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, [])).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - }); - }); - - context('Scenarios', function () { - it('User should post with the free collect module as the collect module and data, allowing non-followers to collect, user two collects without following', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [false]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('UserTwo should collect with success when following if the configuration only allows followers', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('UserTwo should collect with success when following according the follow module set', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistFollowModule(approvalFollowModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userTwoAddress], [true]) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; - }); - - it('UserTwo should mirror the original post, collect with success from their mirror when following the original profile which has no follow module set', async function () { - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, [])).to.not.be.reverted; - }); - }); -}); diff --git a/test/modules/collect/limited-fee-collect-module.spec.ts b/test/modules/collect/limited-fee-collect-module.spec.ts deleted file mode 100644 index d119923..0000000 --- a/test/modules/collect/limited-fee-collect-module.spec.ts +++ /dev/null @@ -1,843 +0,0 @@ -import { BigNumber } from '@ethersproject/contracts/node_modules/@ethersproject/bignumber'; -import { parseEther } from '@ethersproject/units'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - BPS_MAX, - currency, - FIRST_PROFILE_ID, - governance, - lensHub, - limitedFeeCollectModule, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - moduleGlobals, - REFERRAL_FEE_BPS, - treasuryAddress, - TREASURY_FEE_BPS, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Limited Fee Collect Module', function () { - const DEFAULT_COLLECT_PRICE = parseEther('10'); - const DEFAULT_COLLECT_LIMIT = 3; - - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(limitedFeeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Publication Creation', function () { - it('user should fail to post with limited fee collect module using zero collect limit', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [0, DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited fee collect module using unwhitelisted currency', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - userTwoAddress, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited fee collect module using zero recipient', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - ZERO_ADDRESS, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited fee collect module using referral fee greater than max BPS', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, DEFAULT_COLLECT_PRICE, currency.address, userAddress, 10001, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited fee collect module using zero amount', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, 0, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - }); - - context('Collecting', function () { - beforeEach(async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process collect without being the hub', async function () { - await expect( - limitedFeeCollectModule - .connect(userTwo) - .processCollect(0, userTwoAddress, FIRST_PROFILE_ID, 1, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Governance should set the treasury fee BPS to zero, userTwo collecting should not emit a transfer event to the treasury', async function () { - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(1); - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, DEFAULT_COLLECT_PRICE], - currency, - currency.address - ); - }); - - it('UserTwo should mirror the original post, governance should set the treasury fee BPS to zero, userTwo collecting their mirror should not emit a transfer event to the treasury', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(secondProfileId, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(2); - - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const amount = DEFAULT_COLLECT_PRICE.sub(expectedReferralAmount); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, amount], - currency, - currency.address - ); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userTwoAddress, expectedReferralAmount], - currency, - currency.address - ); - }); - - it('UserTwo should fail to collect without following', async function () { - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('UserTwo should fail to collect passing a different expected price in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect passing a different expected currency in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect without first approving module with currency', async function () { - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.ERC20_INSUFFICIENT_ALLOWANCE); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected price in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected currency in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - }); - }); - - context('Scenarios', function () { - it('User should post with limited fee collect module as the collect module and data, correct events should be emitted', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - const tx = lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 1, - MOCK_URI, - limitedFeeCollectModule.address, - collectModuleInitData, - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('User should post with limited fee collect module as the collect module and data, fetched publication data should be accurate', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const fetchedData = await limitedFeeCollectModule.getPublicationData(FIRST_PROFILE_ID, 1); - expect(fetchedData.collectLimit).to.eq(DEFAULT_COLLECT_LIMIT); - expect(fetchedData.amount).to.eq(DEFAULT_COLLECT_PRICE); - expect(fetchedData.recipient).to.eq(userAddress); - expect(fetchedData.currency).to.eq(currency.address); - expect(fetchedData.referralFee).to.eq(REFERRAL_FEE_BPS); - expect(fetchedData.followerOnly).to.eq(true); - }); - - it('User should post with limited fee collect module as the collect module and data, allowing non-followers to collect, user two collects without following and pays fee, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - false, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited fee collect module as the collect module and data, user two follows, then collects and pays fee, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited fee collect module as the collect module and data, user two follows, then collects twice, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(BigNumber.from(DEFAULT_COLLECT_PRICE).mul(2)) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount.mul(2)); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount.mul(2)); - }); - - it('User should post with limited fee collect module as the collect module and data, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const expectedReferrerAmount = BigNumber.from(MAX_UINT256) - .sub(DEFAULT_COLLECT_PRICE) - .add(expectedReferralAmount); - const expectedRecipientAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .sub(expectedReferralAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq(expectedReferrerAmount); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited fee collect module as the collect module and data, with no referral fee, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, DEFAULT_COLLECT_PRICE, currency.address, userAddress, 0, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited fee collect module as the collect module and data, user two mirrors, follows, then collects once from the original, twice from the mirror, and fails to collect a third time from either the mirror or the original', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.be.revertedWith( - ERRORS.MINT_LIMIT_EXCEEDED - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MINT_LIMIT_EXCEEDED - ); - }); - }); -}); diff --git a/test/modules/collect/limited-timed-fee-collect-module.spec.ts b/test/modules/collect/limited-timed-fee-collect-module.spec.ts deleted file mode 100644 index 93c89cc..0000000 --- a/test/modules/collect/limited-timed-fee-collect-module.spec.ts +++ /dev/null @@ -1,917 +0,0 @@ -import { BigNumber } from '@ethersproject/contracts/node_modules/@ethersproject/bignumber'; -import { parseEther } from '@ethersproject/units'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, setNextBlockTimestamp, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - BPS_MAX, - currency, - FIRST_PROFILE_ID, - governance, - lensHub, - limitedTimedFeeCollectModule, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - moduleGlobals, - REFERRAL_FEE_BPS, - treasuryAddress, - TREASURY_FEE_BPS, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Limited Timed Fee Collect Module', function () { - const DEFAULT_COLLECT_PRICE = parseEther('10'); - const DEFAULT_COLLECT_LIMIT = 3; - - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(limitedTimedFeeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Publication Creation', function () { - it('user should fail to post with limited timed fee collect module using zero collect limit', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [0, DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited timed fee collect module using unwhitelisted currency', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - userTwoAddress, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited timed fee collect module using zero recipient', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - ZERO_ADDRESS, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited timed fee collect module using referral fee greater than max BPS', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, DEFAULT_COLLECT_PRICE, currency.address, userAddress, 10001, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with limited timed fee collect module using zero amount', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, 0, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - }); - - context('Collecting', function () { - beforeEach(async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process collect without being the hub', async function () { - await expect( - limitedTimedFeeCollectModule - .connect(userTwo) - .processCollect(0, userTwoAddress, FIRST_PROFILE_ID, 1, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Governance should set the treasury fee BPS to zero, userTwo collecting should not emit a transfer event to the treasury', async function () { - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(1); - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, DEFAULT_COLLECT_PRICE], - currency, - currency.address - ); - }); - - it('UserTwo should mirror the original post, governance should set the treasury fee BPS to zero, userTwo collecting their mirror should not emit a transfer event to the treasury', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(secondProfileId, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(2); - - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const amount = DEFAULT_COLLECT_PRICE.sub(expectedReferralAmount); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, amount], - currency, - currency.address - ); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userTwoAddress, expectedReferralAmount], - currency, - currency.address - ); - }); - - it('UserTwo should fail to collect without following', async function () { - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('UserTwo should fail to collect after the collect end timestmap', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const currentTimestamp = await getTimestamp(); - await setNextBlockTimestamp(Number(currentTimestamp) + 24 * 60 * 60); - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.COLLECT_EXPIRED); - }); - - it('UserTwo should fail to collect passing a different expected price in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect passing a different expected currency in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect without first approving module with currency', async function () { - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.ERC20_INSUFFICIENT_ALLOWANCE); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror after the collect end timestamp', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const currentTimestamp = await getTimestamp(); - await setNextBlockTimestamp(Number(currentTimestamp) + 24 * 60 * 60); - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.COLLECT_EXPIRED - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected price in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected currency in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - }); - }); - - context('Scenarios', function () { - it('User should post with limited timed fee collect module as the collect module and data, correct events should be emitted', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - const tx = lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }); - - const receipt = await waitForTx(tx); - - const postTimestamp = await getTimestamp(); - const endTimestamp = BigNumber.from(postTimestamp).add(24 * 60 * 60); - const expectedData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool', 'uint40'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - endTimestamp, - ] - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 1, - MOCK_URI, - limitedTimedFeeCollectModule.address, - expectedData, - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('User should post with limited timed fee collect module as the collect module and data, fetched publication data should be accurate', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - const postTimestamp = await getTimestamp(); - - const fetchedData = await limitedTimedFeeCollectModule.getPublicationData( - FIRST_PROFILE_ID, - 1 - ); - expect(fetchedData.collectLimit).to.eq(DEFAULT_COLLECT_LIMIT); - expect(fetchedData.amount).to.eq(DEFAULT_COLLECT_PRICE); - expect(fetchedData.recipient).to.eq(userAddress); - expect(fetchedData.currency).to.eq(currency.address); - expect(fetchedData.referralFee).to.eq(REFERRAL_FEE_BPS); - expect(fetchedData.followerOnly).to.eq(true); - expect(fetchedData.endTimestamp).to.eq(BigNumber.from(postTimestamp).add(24 * 60 * 60)); - }); - - it('User should post with limited timed fee collect module as the collect module and data, allowing non-followers to collect, user two collects without following, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - false, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited timed fee collect module as the collect module and data, user two follows, then collects and pays fee, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited timed fee collect module as the collect module and data, user two follows, then collects twice, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(BigNumber.from(DEFAULT_COLLECT_PRICE).mul(2)) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount.mul(2)); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount.mul(2)); - }); - - it('User should post with limited timed fee collect module as the collect module and data, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const expectedReferrerAmount = BigNumber.from(MAX_UINT256) - .sub(DEFAULT_COLLECT_PRICE) - .add(expectedReferralAmount); - const expectedRecipientAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .sub(expectedReferralAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq(expectedReferrerAmount); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited timed fee collect module as the collect module and data, with no referral fee, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_LIMIT, DEFAULT_COLLECT_PRICE, currency.address, userAddress, 0, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with limited timed fee collect module as the collect module and data, user two mirrors, follows, then collects once from the original, twice from the mirror, and fails to collect a third time from either the mirror or the original', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'uint256', 'address', 'address', 'uint16', 'bool'], - [ - DEFAULT_COLLECT_LIMIT, - DEFAULT_COLLECT_PRICE, - currency.address, - userAddress, - REFERRAL_FEE_BPS, - true, - ] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: limitedTimedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(limitedTimedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.be.revertedWith( - ERRORS.MINT_LIMIT_EXCEEDED - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MINT_LIMIT_EXCEEDED - ); - }); - }); -}); diff --git a/test/modules/collect/revert-collect-module.spec.ts b/test/modules/collect/revert-collect-module.spec.ts deleted file mode 100644 index 803b685..0000000 --- a/test/modules/collect/revert-collect-module.spec.ts +++ /dev/null @@ -1,118 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - revertCollectModule, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Revert Collect Module', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(revertCollectModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: revertCollectModule.address, - collectModuleInitData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Collecting', function () { - it('UserTwo should fail to collect without following', async function () { - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith( - ERRORS.COLLECT_NOT_ALLOWED - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, [])).to.be.revertedWith( - ERRORS.COLLECT_NOT_ALLOWED - ); - }); - - it('UserTwo should fail to collect while following', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, [])).to.be.revertedWith( - ERRORS.COLLECT_NOT_ALLOWED - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror while following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, [])).to.be.revertedWith( - ERRORS.COLLECT_NOT_ALLOWED - ); - }); - }); -}); diff --git a/test/modules/collect/timed-fee-collect-module.spec.ts b/test/modules/collect/timed-fee-collect-module.spec.ts deleted file mode 100644 index 20ded90..0000000 --- a/test/modules/collect/timed-fee-collect-module.spec.ts +++ /dev/null @@ -1,759 +0,0 @@ -import { BigNumber } from '@ethersproject/contracts/node_modules/@ethersproject/bignumber'; -import { parseEther } from '@ethersproject/units'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, setNextBlockTimestamp, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - BPS_MAX, - currency, - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - moduleGlobals, - REFERRAL_FEE_BPS, - timedFeeCollectModule, - treasuryAddress, - TREASURY_FEE_BPS, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Timed Fee Collect Module', function () { - const DEFAULT_COLLECT_PRICE = parseEther('10'); - - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(timedFeeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Publication Creation', function () { - it('user should fail to post with timed fee collect module using unwhitelisted currency', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, userTwoAddress, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with timed fee collect module using zero recipient', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, ZERO_ADDRESS, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with timed fee collect module using referral fee greater than max BPS', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, 10001, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to post with timed fee collect module using zero amount', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [0, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - }); - - context('Collecting', function () { - beforeEach(async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process collect without being the hub', async function () { - await expect( - timedFeeCollectModule - .connect(userTwo) - .processCollect(0, userTwoAddress, FIRST_PROFILE_ID, 1, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Governance should set the treasury fee BPS to zero, userTwo collecting should not emit a transfer event to the treasury', async function () { - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(1); - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, DEFAULT_COLLECT_PRICE], - currency, - currency.address - ); - }); - - it('UserTwo should mirror the original post, governance should set the treasury fee BPS to zero, userTwo collecting their mirror should not emit a transfer event to the treasury', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).collect(secondProfileId, 1, data); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(2); - - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const amount = DEFAULT_COLLECT_PRICE.sub(expectedReferralAmount); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, amount], - currency, - currency.address - ); - - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userTwoAddress, expectedReferralAmount], - currency, - currency.address - ); - }); - - it('UserTwo should fail to collect without following', async function () { - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('UserTwo should fail to collect after the collect end timestmap', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const currentTimestamp = await getTimestamp(); - await setNextBlockTimestamp(Number(currentTimestamp) + 24 * 60 * 60); - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.COLLECT_EXPIRED); - }); - - it('UserTwo should fail to collect passing a different expected price in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect passing a different expected currency in data', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to collect without first approving module with currency', async function () { - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect( - lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data) - ).to.be.revertedWith(ERRORS.ERC20_INSUFFICIENT_ALLOWANCE); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror without following the original profile', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror after the collect end timestamp', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const currentTimestamp = await getTimestamp(); - await setNextBlockTimestamp(Number(currentTimestamp) + 24 * 60 * 60); - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.COLLECT_EXPIRED - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected price in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE.div(2)] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - - it('UserTwo should mirror the original post, fail to collect from their mirror passing a different expected currency in data', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_COLLECT_PRICE]); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.be.revertedWith( - ERRORS.MODULE_DATA_MISMATCH - ); - }); - }); - }); - - context('Scenarios', function () { - it('User should post with timed fee collect module as the collect module and data, correct events should be emitted', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - - const tx = lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }); - - const receipt = await waitForTx(tx); - - const postTimestamp = await getTimestamp(); - const endTimestamp = BigNumber.from(postTimestamp).add(24 * 60 * 60); - const expectedData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool', 'uint40'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true, endTimestamp] - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 1, - MOCK_URI, - timedFeeCollectModule.address, - expectedData, - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('User should post with timed fee collect module as the collect module and data, fetched publication data should be accurate', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - const postTimestamp = await getTimestamp(); - - const fetchedData = await timedFeeCollectModule.getPublicationData(FIRST_PROFILE_ID, 1); - expect(fetchedData.amount).to.eq(DEFAULT_COLLECT_PRICE); - expect(fetchedData.recipient).to.eq(userAddress); - expect(fetchedData.currency).to.eq(currency.address); - expect(fetchedData.referralFee).to.eq(REFERRAL_FEE_BPS); - expect(fetchedData.followerOnly).to.eq(true); - expect(fetchedData.endTimestamp).to.eq(BigNumber.from(postTimestamp).add(24 * 60 * 60)); - }); - - it('User should post with timed fee collect module as the collect module and data, allowing non-followers to collect, user two collects without following, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, false] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with timed fee collect module as the collect module and data, user two follows, then collects and pays fee, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with timed fee collect module as the collect module and data, user two follows, then collects twice, fee distribution is valid', async function () { - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - await expect(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(BigNumber.from(DEFAULT_COLLECT_PRICE).mul(2)) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount.mul(2)); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount.mul(2)); - }); - - it('User should post with timed fee collect module as the collect module and data, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, REFERRAL_FEE_BPS, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedReferralAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .mul(REFERRAL_FEE_BPS) - .div(BPS_MAX); - const expectedReferrerAmount = BigNumber.from(MAX_UINT256) - .sub(DEFAULT_COLLECT_PRICE) - .add(expectedReferralAmount); - const expectedRecipientAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .sub(expectedTreasuryAmount) - .sub(expectedReferralAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq(expectedReferrerAmount); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should post with timed fee collect module as the collect module and data, with no referral fee, user two mirrors, follows, then collects from their mirror and pays fee, fee distribution is valid', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [DEFAULT_COLLECT_PRICE, currency.address, userAddress, 0, true] - ); - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: timedFeeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(timedFeeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_COLLECT_PRICE] - ); - await expect(lensHub.connect(userTwo).collect(secondProfileId, 1, data)).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_COLLECT_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_COLLECT_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_COLLECT_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - }); -}); diff --git a/test/modules/follow/approval-follow-module.spec.ts b/test/modules/follow/approval-follow-module.spec.ts deleted file mode 100644 index c6f4178..0000000 --- a/test/modules/follow/approval-follow-module.spec.ts +++ /dev/null @@ -1,238 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - approvalFollowModule, - FIRST_PROFILE_ID, - governance, - lensHub, - lensHubImpl, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - user, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Approval Follow Module', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistFollowModule(approvalFollowModule.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Initialization', function () { - it('Initialize call should fail when sender is not the hub', async function () { - await expect( - approvalFollowModule.initializeFollowModule(FIRST_PROFILE_ID, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - }); - - context('Approvals', function () { - it('Approve should fail when calling it with addresses and toApprove params having different lengths', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userTwoAddress], []) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('Approve should fail when sender differs from profile owner', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(userTwo).approve(FIRST_PROFILE_ID, [userTwoAddress], [false]) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); - }); - }); - - context('Processing follow', function () { - it('UserTwo should fail to process follow without being the hub', async function () { - await expect( - approvalFollowModule.connect(userTwo).processFollow(userTwoAddress, FIRST_PROFILE_ID, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Follow should fail when follower address is not approved', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith( - ERRORS.FOLLOW_NOT_APPROVED - ); - }); - - it('Follow should fail when follower address approval is revoked after being approved', async function () { - const data = abiCoder.encode(['address[]'], [[userTwoAddress]]); - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, data) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userTwoAddress], [false]) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith( - ERRORS.FOLLOW_NOT_APPROVED - ); - }); - - it('Follow should fail when follower address is not approved even when following itself', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith( - ERRORS.FOLLOW_NOT_APPROVED - ); - }); - }); - }); - - context('Scenarios', function () { - context('Initialization', function () { - it('Profile creation with initial approval data should emit expected event', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - const data = abiCoder.encode(['address[]'], [[userTwoAddress]]); - - const tx = lensHub.createProfile({ - to: userAddress, - handle: 'secondhandle', - imageURI: MOCK_PROFILE_URI, - followModule: approvalFollowModule.address, - followModuleInitData: data, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(2); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userAddress, secondProfileId], lensHubImpl); - matchEvent(receipt, 'ProfileCreated', [ - secondProfileId, - userAddress, - userAddress, - 'secondhandle', - MOCK_PROFILE_URI, - approvalFollowModule.address, - data, - MOCK_FOLLOW_NFT_URI, - await getTimestamp(), - ]); - }); - - it('Setting follow module with initial approval data should emit expected event', async function () { - const data = abiCoder.encode(['address[]'], [[userTwoAddress]]); - const tx = lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, data); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleSet', [ - FIRST_PROFILE_ID, - approvalFollowModule.address, - data, - await getTimestamp(), - ]); - }); - - it('Setting follow module should work when calling it without initial approval data', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - }); - - it('Setting follow module should work when calling it with initial approval data', async function () { - const data = abiCoder.encode(['address[]'], [[userTwoAddress]]); - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, data) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - }); - }); - - context('Approvals and follows', function () { - it('Approval should emit expected event', async function () { - const tx = approvalFollowModule - .connect(user) - .approve(FIRST_PROFILE_ID, [userTwoAddress], [true]); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowsApproved', [ - userAddress, - FIRST_PROFILE_ID, - [userTwoAddress], - [true], - await getTimestamp(), - ]); - }); - - it('Follow call should work when address was previously approved', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userTwoAddress], [true]) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - }); - - it('Follow call to self should work when address was previously approved', async function () { - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ).to.not.be.reverted; - await expect( - approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userAddress], [true]) - ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - }); - }); - - context('View Functions', function () { - beforeEach(async function () { - const data = abiCoder.encode(['address[]'], [[userTwoAddress]]); - await expect( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, data) - ).to.not.be.reverted; - }); - - it('Single approval getter should return expected values', async function () { - expect( - await approvalFollowModule.isApproved(userAddress, FIRST_PROFILE_ID, userTwoAddress) - ).to.eq(true); - - expect( - await approvalFollowModule.isApproved(userAddress, FIRST_PROFILE_ID, userAddress) - ).to.eq(false); - }); - - it('Array approval getter should return expected values', async function () { - const result = await approvalFollowModule.isApprovedArray(userAddress, FIRST_PROFILE_ID, [ - userTwoAddress, - userAddress, - ]); - expect(result[0]).to.eq(true); - expect(result[1]).to.eq(false); - }); - }); - }); -}); diff --git a/test/modules/follow/fee-follow-module.spec.ts b/test/modules/follow/fee-follow-module.spec.ts deleted file mode 100644 index e68b169..0000000 --- a/test/modules/follow/fee-follow-module.spec.ts +++ /dev/null @@ -1,349 +0,0 @@ -import { BigNumber } from '@ethersproject/contracts/node_modules/@ethersproject/bignumber'; -import { parseEther } from '@ethersproject/units'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { MAX_UINT256, ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - BPS_MAX, - currency, - feeFollowModule, - FIRST_PROFILE_ID, - governance, - lensHub, - lensHubImpl, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - moduleGlobals, - treasuryAddress, - TREASURY_FEE_BPS, - userAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Fee Follow Module', function () { - const DEFAULT_FOLLOW_PRICE = parseEther('10'); - - beforeEach(async function () { - await expect( - lensHub.connect(governance).whitelistFollowModule(feeFollowModule.address, true) - ).to.not.be.reverted; - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Initialization', function () { - it('user should fail to create a profile with fee follow module using unwhitelisted currency', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, userTwoAddress, userAddress] - ); - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to create a profile with fee follow module using zero recipient', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, ZERO_ADDRESS] - ); - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - - it('user should fail to create a profile with fee follow module using zero amount', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [0, currency.address, userAddress] - ); - - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.be.revertedWith(ERRORS.INIT_PARAMS_INVALID); - }); - }); - - context('Following', function () { - beforeEach(async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process follow without being the hub', async function () { - await expect( - feeFollowModule.connect(userTwo).processFollow(userTwoAddress, FIRST_PROFILE_ID, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Governance should set the treasury fee BPS to zero, userTwo following should not emit a transfer event to the treasury', async function () { - await expect(moduleGlobals.connect(governance).setTreasuryFee(0)).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_FOLLOW_PRICE] - ); - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeFollowModule.address, MAX_UINT256) - ).to.not.be.reverted; - - const tx = lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]); - const receipt = await waitForTx(tx); - - let currencyEventCount = 0; - for (let log of receipt.logs) { - if (log.address == currency.address) { - currencyEventCount++; - } - } - expect(currencyEventCount).to.eq(1); - matchEvent( - receipt, - 'Transfer', - [userTwoAddress, userAddress, DEFAULT_FOLLOW_PRICE], - currency, - currency.address - ); - }); - - it('UserTwo should fail to follow passing a different expected price in data', async function () { - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_FOLLOW_PRICE.div(2)] - ); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to follow passing a different expected currency in data', async function () { - const data = abiCoder.encode(['address', 'uint256'], [userAddress, DEFAULT_FOLLOW_PRICE]); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.be.revertedWith(ERRORS.MODULE_DATA_MISMATCH); - }); - - it('UserTwo should fail to follow without first approving module with currency', async function () { - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_FOLLOW_PRICE] - ); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.be.revertedWith(ERRORS.ERC20_INSUFFICIENT_ALLOWANCE); - }); - }); - }); - - context('Scenarios', function () { - it('User should create a profile with the fee follow module as the follow module and data, correct events should be emitted', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - const tx = lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(2); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userAddress, FIRST_PROFILE_ID], lensHubImpl); - matchEvent(receipt, 'ProfileCreated', [ - FIRST_PROFILE_ID, - userAddress, - userAddress, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - feeFollowModule.address, - followModuleInitData, - MOCK_FOLLOW_NFT_URI, - await getTimestamp(), - ]); - }); - - it('User should create a profile then set the fee follow module as the follow module with data, correct events should be emitted', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - const tx = lensHub.setFollowModule( - FIRST_PROFILE_ID, - feeFollowModule.address, - followModuleInitData - ); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleSet', [ - FIRST_PROFILE_ID, - feeFollowModule.address, - followModuleInitData, - await getTimestamp(), - ]); - }); - - it('User should create a profile with the fee follow module as the follow module and data, fetched profile data should be accurate', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - const fetchedData = await feeFollowModule.getProfileData(FIRST_PROFILE_ID); - expect(fetchedData.amount).to.eq(DEFAULT_FOLLOW_PRICE); - expect(fetchedData.recipient).to.eq(userAddress); - expect(fetchedData.currency).to.eq(currency.address); - }); - - it('User should create a profile with the fee follow module as the follow module and data, user two follows, fee distribution is valid', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeFollowModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_FOLLOW_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data])).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_FOLLOW_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_FOLLOW_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(DEFAULT_FOLLOW_PRICE) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount); - }); - - it('User should create a profile with the fee follow module as the follow module and data, user two follows twice, fee distribution is valid', async function () { - const followModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address'], - [DEFAULT_FOLLOW_PRICE, currency.address, userAddress] - ); - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: feeFollowModule.address, - followModuleInitData: followModuleInitData, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeFollowModule.address, MAX_UINT256) - ).to.not.be.reverted; - const data = abiCoder.encode( - ['address', 'uint256'], - [currency.address, DEFAULT_FOLLOW_PRICE] - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data])).to.not.be.reverted; - - const expectedTreasuryAmount = BigNumber.from(DEFAULT_FOLLOW_PRICE) - .mul(TREASURY_FEE_BPS) - .div(BPS_MAX); - const expectedRecipientAmount = - BigNumber.from(DEFAULT_FOLLOW_PRICE).sub(expectedTreasuryAmount); - - expect(await currency.balanceOf(userTwoAddress)).to.eq( - BigNumber.from(MAX_UINT256).sub(BigNumber.from(DEFAULT_FOLLOW_PRICE).mul(2)) - ); - expect(await currency.balanceOf(userAddress)).to.eq(expectedRecipientAmount.mul(2)); - expect(await currency.balanceOf(treasuryAddress)).to.eq(expectedTreasuryAmount.mul(2)); - }); - }); -}); diff --git a/test/modules/follow/profile-follow-module.spec.ts b/test/modules/follow/profile-follow-module.spec.ts deleted file mode 100644 index f0b7ea6..0000000 --- a/test/modules/follow/profile-follow-module.spec.ts +++ /dev/null @@ -1,304 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { BytesLike } from 'ethers'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - abiCoder, - FIRST_PROFILE_ID, - governance, - lensHub, - lensHubImpl, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - profileFollowModule, - userAddress, - userThreeAddress, - userTwo, - userTwoAddress, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Profile Follow Module', function () { - let EMPTY_BYTES: BytesLike; - let DEFAULT_FOLLOW_DATA: BytesLike; - - before(async function () { - EMPTY_BYTES = '0x'; - DEFAULT_FOLLOW_DATA = abiCoder.encode(['uint256'], [FIRST_PROFILE_ID + 1]); - await expect( - lensHub.connect(governance).whitelistFollowModule(profileFollowModule.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Initialization', function () { - it('Initialize call should fail when sender is not the hub', async function () { - await expect( - profileFollowModule.initializeFollowModule(FIRST_PROFILE_ID, EMPTY_BYTES) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - }); - - context('Following', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: profileFollowModule.address, - followModuleInitData: EMPTY_BYTES, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - it('UserTwo should fail to process follow without being the hub', async function () { - await expect( - profileFollowModule.connect(userTwo).processFollow(userTwoAddress, FIRST_PROFILE_ID, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('Follow should fail when data is not holding the follower profile id encoded', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [])).to.be.revertedWith( - ERRORS.ARRAY_MISMATCH - ); - }); - - it('Follow should fail when the passed follower profile does not exist because has never been minted', async function () { - const data = abiCoder.encode(['uint256'], [FIRST_PROFILE_ID + 1]); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.be.revertedWith(ERRORS.ERC721_QUERY_FOR_NONEXISTENT_TOKEN); - }); - - it('Follow should fail when the passed follower profile does not exist because has been burned', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).burn(secondProfileId)).to.not.be.reverted; - - const data = abiCoder.encode(['uint256'], [secondProfileId]); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.be.revertedWith(ERRORS.ERC721_QUERY_FOR_NONEXISTENT_TOKEN); - }); - - it('Follow should fail when follower address is not the owner of the passed follower profile', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: 'user', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER); - }); - - it('Follow should fail when the passed follower profile has already followed the profile', async function () { - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.not.be.reverted; - const followerProfileId = FIRST_PROFILE_ID + 1; - expect( - await profileFollowModule.isProfileFollowing(followerProfileId, FIRST_PROFILE_ID) - ).to.be.true; - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('Follow should fail when the passed follower profile has already followed the profile even after the profile nft has been transfered', async function () { - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.not.be.reverted; - const followerProfileId = FIRST_PROFILE_ID + 1; - expect( - await profileFollowModule.isProfileFollowing(followerProfileId, FIRST_PROFILE_ID) - ).to.be.true; - - await expect( - lensHub.transferFrom(userAddress, userThreeAddress, FIRST_PROFILE_ID) - ).to.not.be.reverted; - expect( - await profileFollowModule.isProfileFollowing(followerProfileId, FIRST_PROFILE_ID) - ).to.be.true; - - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - }); - }); - - context('Scenarios', function () { - context('Initialization', function () { - it('Initialize call should succeed returning empty bytes even when sending non-empty data as input', async function () { - expect( - await profileFollowModule - .connect(lensHub.address) - .callStatic.initializeFollowModule(FIRST_PROFILE_ID, abiCoder.encode(['uint256'], [0])) - ).to.eq(EMPTY_BYTES); - }); - - it('Profile creation using profile follow module should succeed and emit expected event', async function () { - const tx = lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: profileFollowModule.address, - followModuleInitData: EMPTY_BYTES, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(2); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userAddress, FIRST_PROFILE_ID], lensHubImpl); - matchEvent(receipt, 'ProfileCreated', [ - FIRST_PROFILE_ID, - userAddress, - userAddress, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - profileFollowModule.address, - EMPTY_BYTES, - MOCK_FOLLOW_NFT_URI, - await getTimestamp(), - ]); - }); - - it('User should create a profile then set the profile follow module as the follow module, correct event should be emitted', async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - const tx = lensHub.setFollowModule( - FIRST_PROFILE_ID, - profileFollowModule.address, - EMPTY_BYTES - ); - - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleSet', [ - FIRST_PROFILE_ID, - profileFollowModule.address, - EMPTY_BYTES, - await getTimestamp(), - ]); - }); - }); - - context('Processing follow', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: profileFollowModule.address, - followModuleInitData: EMPTY_BYTES, - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - it('Follow call should work when follower profile exists, is owned by the follower address and has not already followed the profile', async function () { - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - const followerProfileId = FIRST_PROFILE_ID + 1; - expect( - await profileFollowModule.isProfileFollowing(followerProfileId, FIRST_PROFILE_ID) - ).to.be.false; - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.not.be.reverted; - }); - - it('Follow call should work with each of your profiles when you have more than one', async function () { - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'usertwo2', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [DEFAULT_FOLLOW_DATA]) - ).to.not.be.reverted; - const data = abiCoder.encode(['uint256'], [FIRST_PROFILE_ID + 2]); - await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [data]) - ).to.not.be.reverted; - }); - }); - }); -}); diff --git a/test/modules/follow/revert-follow-module.spec.ts b/test/modules/follow/revert-follow-module.spec.ts deleted file mode 100644 index 6cf57b6..0000000 --- a/test/modules/follow/revert-follow-module.spec.ts +++ /dev/null @@ -1,69 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { - FIRST_PROFILE_ID, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - revertFollowModule, - userAddress, - userTwo, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Revert Follow Module', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistFollowModule(revertFollowModule.address, true) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - context('Initialization', function () { - it('Initialize call should fail when sender is not the hub', async function () { - await expect( - revertFollowModule.initializeFollowModule(FIRST_PROFILE_ID, []) - ).to.be.revertedWith(ERRORS.NOT_HUB); - }); - }); - - context('Processing follow', function () { - it('UserTwo should fail to process follow', async function () { - await lensHub.setFollowModule(FIRST_PROFILE_ID, revertFollowModule.address, []); - expect(await lensHub.getFollowModule(FIRST_PROFILE_ID)).to.be.equal( - revertFollowModule.address - ); - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.be.revertedWith( - ERRORS.FOLLOW_INVALID - ); - }); - }); - }); - - context('Scenarios', function () { - context('Initialization', function () { - it('Initialize call should succeed when passing non empty data and return empty bytes', async function () { - const nonEmptyData = '0x1234'; - expect( - await revertFollowModule - .connect(lensHub.address) - .initializeFollowModule(FIRST_PROFILE_ID, nonEmptyData) - ).to.be.equals('0x'); - }); - }); - }); -}); diff --git a/test/modules/reference/follower-only-reference-module.spec.ts b/test/modules/reference/follower-only-reference-module.spec.ts deleted file mode 100644 index 27aec47..0000000 --- a/test/modules/reference/follower-only-reference-module.spec.ts +++ /dev/null @@ -1,395 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { FollowNFT__factory } from '../../../typechain-types'; -import { ZERO_ADDRESS } from '../../helpers/constants'; -import { ERRORS } from '../../helpers/errors'; -import { getTimestamp, matchEvent, waitForTx } from '../../helpers/utils'; -import { - freeCollectModule, - FIRST_PROFILE_ID, - followerOnlyReferenceModule, - governance, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - user, - userAddress, - userThreeAddress, - userTwo, - userTwoAddress, - abiCoder, -} from '../../__setup.spec'; - -makeSuiteCleanRoom('Follower Only Reference Module', function () { - const SECOND_PROFILE_ID = FIRST_PROFILE_ID + 1; - - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub.createProfile({ - to: userTwoAddress, - handle: 'user2', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - await expect( - lensHub - .connect(governance) - .whitelistReferenceModule(followerOnlyReferenceModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ).to.not.be.reverted; - await expect( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: followerOnlyReferenceModule.address, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - // We don't need a `publishing` or `initialization` context because initialization never reverts in the FollowerOnlyReferenceModule. - context('Commenting', function () { - it('Commenting should fail if commenter is not a follower and follow NFT not yet deployed', async function () { - await expect( - lensHub.connect(userTwo).comment({ - profileId: SECOND_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('Commenting should fail if commenter follows, then transfers the follow NFT before attempting to comment', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - followNFT.connect(userTwo).transferFrom(userTwoAddress, userThreeAddress, 1) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).comment({ - profileId: SECOND_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - }); - - context('Mirroring', function () { - it('Mirroring should fail if mirrorer is not a follower and follow NFT not yet deployed', async function () { - await expect( - lensHub.connect(userTwo).mirror({ - profileId: SECOND_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - - it('Mirroring should fail if mirrorer follows, then transfers the follow NFT before attempting to mirror', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - followNFT.connect(userTwo).transferFrom(userTwoAddress, userAddress, 1) - ).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: SECOND_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.be.revertedWith(ERRORS.FOLLOW_INVALID); - }); - }); - }); - - context('Scenarios', function () { - context('Publishing', function () { - it('Posting with follower only reference module as reference module should emit expected events', async function () { - const tx = lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: followerOnlyReferenceModule.address, - referenceModuleInitData: [], - }); - const receipt = await waitForTx(tx); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 2, - MOCK_URI, - freeCollectModule.address, - abiCoder.encode(['bool'], [true]), - followerOnlyReferenceModule.address, - [], - await getTimestamp(), - ]); - }); - }); - - context('Commenting', function () { - it('Commenting should work if the commenter is a follower', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - lensHub.connect(userTwo).comment({ - profileId: SECOND_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Commenting should work if the commenter is the publication owner and he is following himself', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Commenting should work if the commenter is the publication owner even when he is not following himself and follow NFT was not deployed', async function () { - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Commenting should work if the commenter is the publication owner even when he is not following himself and follow NFT was deployed', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.transferFrom(userAddress, userTwoAddress, 1)).to.not.be.reverted; - - await expect( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Commenting should work if the commenter follows, transfers the follow NFT then receives it back before attempting to comment', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - followNFT.connect(userTwo).transferFrom(userTwoAddress, userAddress, 1) - ).to.not.be.reverted; - - await expect(followNFT.transferFrom(userAddress, userTwoAddress, 1)).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).comment({ - profileId: SECOND_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - }); - - context('Mirroring', function () { - it('Mirroring should work if mirrorer is a follower', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: SECOND_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Mirroring should work if mirrorer follows, transfers the follow NFT then receives it back before attempting to mirror', async function () { - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - followNFT.connect(userTwo).transferFrom(userTwoAddress, userAddress, 1) - ).to.not.be.reverted; - - await expect(followNFT.transferFrom(userAddress, userTwoAddress, 1)).to.not.be.reverted; - - await expect( - lensHub.connect(userTwo).mirror({ - profileId: SECOND_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Mirroring should work if the mirrorer is the publication owner and he is following himself', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Mirroring should work if the mirrorer is the publication owner even when he is not following himself and follow NFT was not deployed', async function () { - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - - it('Mirroring should work if the mirrorer is the publication owner even when he is not following himself and follow NFT was deployed', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.transferFrom(userAddress, userTwoAddress, 1)).to.not.be.reverted; - - await expect( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ).to.not.be.reverted; - }); - }); - }); -}); diff --git a/test/nft/collect-nft.spec.ts b/test/nft/collect-nft.spec.ts index 5047093..146010c 100644 --- a/test/nft/collect-nft.spec.ts +++ b/test/nft/collect-nft.spec.ts @@ -47,15 +47,15 @@ makeSuiteCleanRoom('Collect NFT', function () { referenceModuleInitData: [], }) ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.collect(FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.collect(userAddress, FIRST_PROFILE_ID, 1, [])).to.not.be.reverted; collectNFT = CollectNFT__factory.connect( await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1), user ); }); - context('Negatives', function () { + context.skip('Negatives', function () { it('User should fail to reinitialize the collect NFT', async function () { await expect(collectNFT.initialize(FIRST_PROFILE_ID, 1, 'name', 'symbol')).to.be.revertedWith( ERRORS.INITIALIZED @@ -90,7 +90,7 @@ makeSuiteCleanRoom('Collect NFT', function () { }); }); - context('Scenarios', function () { + context.skip('Scenarios', function () { it('Collect NFT URI should be valid', async function () { expect(await collectNFT.tokenURI(1)).to.eq(MOCK_URI); }); diff --git a/test/nft/follow-nft.spec.ts b/test/nft/follow-nft.spec.ts deleted file mode 100644 index eb17779..0000000 --- a/test/nft/follow-nft.spec.ts +++ /dev/null @@ -1,482 +0,0 @@ -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { FollowNFT, FollowNFT__factory } from '../../typechain-types'; -import { MAX_UINT256, ZERO_ADDRESS } from '../helpers/constants'; -import { ERRORS } from '../helpers/errors'; -import { - cancelWithPermitForAll, - getBlockNumber, - getDelegateBySigParts, - mine, -} from '../helpers/utils'; -import { - FIRST_PROFILE_ID, - governanceAddress, - helper, - lensHub, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - OTHER_MOCK_URI, - testWallet, - user, - userAddress, - userTwo, - userTwoAddress, -} from '../__setup.spec'; - -makeSuiteCleanRoom('Follow NFT', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - context('generic', function () { - context('Negatives', function () { - it('User should follow, and fail to re-initialize the follow NFT', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.initialize(FIRST_PROFILE_ID)).to.be.revertedWith( - ERRORS.INITIALIZED - ); - }); - - it("User should follow, userTwo should fail to burn user's follow NFT", async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - userTwo - ); - - await expect(followNFT.burn(1)).to.be.revertedWith(ERRORS.NOT_OWNER_OR_APPROVED); - }); - - it('User should follow, then fail to mint a follow NFT directly', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.mint(userAddress)).to.be.revertedWith(ERRORS.NOT_HUB); - }); - - it('User should follow, then fail to get the power at a future block', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - const blockNumber = await getBlockNumber(); - - await expect( - followNFT.getPowerByBlockNumber(userAddress, blockNumber + 1) - ).to.be.revertedWith(ERRORS.BLOCK_NUMBER_INVALID); - await expect(followNFT.getDelegatedSupplyByBlockNumber(blockNumber + 1)).to.be.revertedWith( - ERRORS.BLOCK_NUMBER_INVALID - ); - }); - - it('user should follow, then fail to get the URI for a token that does not exist', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - await expect(followNFT.tokenURI(2)).to.be.revertedWith(ERRORS.TOKEN_DOES_NOT_EXIST); - }); - }); - - context('Scenarios', function () { - it('User should follow, then burn their follow NFT, governance power is zero before and after', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - const firstCheckpointBlock = await getBlockNumber(); - - await expect(followNFT.burn(1)).to.not.be.reverted; - - const secondCheckpointBlock = await getBlockNumber(); - - expect(await followNFT.getPowerByBlockNumber(userAddress, firstCheckpointBlock)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(firstCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userAddress, secondCheckpointBlock)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(secondCheckpointBlock)).to.eq(0); - }); - - it('User should follow, delegate to themself, governance power should be zero before the last block, and 1 at the current block', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.delegate(userAddress)).to.not.be.reverted; - - const blockNumber = await getBlockNumber(); - - expect(await followNFT.getPowerByBlockNumber(userAddress, blockNumber - 1)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(blockNumber - 1)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userAddress, blockNumber)).to.eq(1); - expect(await followNFT.getDelegatedSupplyByBlockNumber(blockNumber)).to.eq(1); - }); - - it('User and userTwo should follow, governance power should be zero, then users delegate multiple times, governance power should be accurate throughout', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - const firstCheckpointBlock = await getBlockNumber(); - - // First, users delegate to themselves - await expect(followNFT.delegate(userAddress)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(userTwoAddress)).to.not.be.reverted; - const secondCheckpointBlock = await getBlockNumber(); - - // Second, userTWo delegates to user - await expect(followNFT.connect(userTwo).delegate(userAddress)).to.not.be.reverted; - const thirdCheckpointBlock = await getBlockNumber(); - - // Third, user delegates to userTwo - await expect(followNFT.delegate(userTwoAddress)).to.not.be.reverted; - const fourthCheckpointBlock = await getBlockNumber(); - - // Fourth, users delegate to governance - await expect(followNFT.delegate(governanceAddress)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(governanceAddress)).to.not.be.reverted; - const fifthCheckpointBlock = await getBlockNumber(); - - // Fifth, users delegate to zero (remove delegation) - await expect(followNFT.delegate(ZERO_ADDRESS)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(ZERO_ADDRESS)).to.not.be.reverted; - const sixthCheckpointBlock = await getBlockNumber(); - - // Sixth, users delegate to user - await expect(followNFT.delegate(userAddress)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(userAddress)).to.not.be.reverted; - const seventhCheckpointBlock = await getBlockNumber(); - - // First validation - expect(await followNFT.getPowerByBlockNumber(userAddress, firstCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, firstCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(firstCheckpointBlock)).to.eq(0); - - // Second validation - expect(await followNFT.getPowerByBlockNumber(userAddress, secondCheckpointBlock)).to.eq(1); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, secondCheckpointBlock)).to.eq( - 1 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(secondCheckpointBlock)).to.eq(2); - - // Third validation - expect(await followNFT.getPowerByBlockNumber(userAddress, thirdCheckpointBlock)).to.eq(2); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, thirdCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(thirdCheckpointBlock)).to.eq(2); - - // Fourth validation - expect(await followNFT.getPowerByBlockNumber(userAddress, fourthCheckpointBlock)).to.eq(1); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, fourthCheckpointBlock)).to.eq( - 1 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(fourthCheckpointBlock)).to.eq(2); - - // Fifth validation - expect(await followNFT.getPowerByBlockNumber(userAddress, fifthCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, fifthCheckpointBlock)).to.eq( - 0 - ); - expect( - await followNFT.getPowerByBlockNumber(governanceAddress, fifthCheckpointBlock) - ).to.eq(2); - expect(await followNFT.getDelegatedSupplyByBlockNumber(fifthCheckpointBlock)).to.eq(2); - - // Sixth validation - expect(await followNFT.getPowerByBlockNumber(userAddress, sixthCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, sixthCheckpointBlock)).to.eq( - 0 - ); - expect( - await followNFT.getPowerByBlockNumber(governanceAddress, sixthCheckpointBlock) - ).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(ZERO_ADDRESS, sixthCheckpointBlock)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(sixthCheckpointBlock)).to.eq(0); - - // Seventh validation - expect(await followNFT.getPowerByBlockNumber(userAddress, seventhCheckpointBlock)).to.eq(2); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, seventhCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(seventhCheckpointBlock)).to.eq(2); - }); - - it('User and userTwo should follow, delegate to themselves, 10 blocks later user delegates to userTwo, 10 blocks later both delegate to user, governance power should be accurate throughout', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.delegate(userAddress)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(userTwoAddress)).to.not.be.reverted; - const firstCheckpointBlock = await getBlockNumber(); - - await mine(10); - - await expect(followNFT.delegate(userTwoAddress)).to.not.be.reverted; - const secondCheckpointBlock = await getBlockNumber(); - - await mine(10); - - await expect(followNFT.delegate(userAddress)).to.not.be.reverted; - await expect(followNFT.connect(userTwo).delegate(userAddress)).to.not.be.reverted; - const thirdCheckpointBlock = await getBlockNumber(); - - // First validation - expect(await followNFT.getPowerByBlockNumber(userAddress, firstCheckpointBlock)).to.eq(1); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, firstCheckpointBlock)).to.eq( - 1 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(firstCheckpointBlock)).to.eq(2); - - // Second validation - expect(await followNFT.getPowerByBlockNumber(userAddress, secondCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, secondCheckpointBlock)).to.eq( - 2 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(secondCheckpointBlock)).to.eq(2); - - // Last validation - expect(await followNFT.getPowerByBlockNumber(userAddress, thirdCheckpointBlock)).to.eq(2); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, thirdCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(secondCheckpointBlock)).to.eq(2); - }); - - it('user and userTwo should follow, user delegates to userTwo twice, governance power should be accurate', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.delegate(userTwoAddress)).to.not.be.reverted; - await expect(followNFT.delegate(userTwoAddress)).to.not.be.reverted; - - const blockNumber = await getBlockNumber(); - expect(await followNFT.getPowerByBlockNumber(userAddress, blockNumber)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, blockNumber)).to.eq(1); - expect(await followNFT.getDelegatedSupplyByBlockNumber(blockNumber)).to.eq(1); - }); - - it('User and userTwo should follow, then transfer their NFTs to the helper contract, then the helper contract batch delegates to user one, then user two, governance power should be accurate', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - - await expect(followNFT.transferFrom(userAddress, helper.address, 1)).to.not.be.reverted; - await expect( - followNFT.connect(userTwo).transferFrom(userTwoAddress, helper.address, 2) - ).to.not.be.reverted; - - const firstCheckpointBlock = await getBlockNumber(); - await expect( - helper.batchDelegate(followNFT.address, userAddress, userTwoAddress) - ).to.not.be.reverted; - - const secondCheckpointBlock = await getBlockNumber(); - - // First validation - expect(await followNFT.getPowerByBlockNumber(userAddress, firstCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, firstCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getPowerByBlockNumber(helper.address, firstCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(firstCheckpointBlock)).to.eq(0); - - // Second validation - expect(await followNFT.getPowerByBlockNumber(userAddress, secondCheckpointBlock)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(userTwoAddress, secondCheckpointBlock)).to.eq( - 2 - ); - expect(await followNFT.getPowerByBlockNumber(helper.address, secondCheckpointBlock)).to.eq( - 0 - ); - expect(await followNFT.getDelegatedSupplyByBlockNumber(secondCheckpointBlock)).to.eq(2); - }); - - it('user should follow, then get the URI for their token, URI should be accurate', async function () { - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - const followNFT = FollowNFT__factory.connect( - await lensHub.getFollowNFT(FIRST_PROFILE_ID), - user - ); - expect(await followNFT.tokenURI(1)).to.eq(MOCK_FOLLOW_NFT_URI); - }); - }); - }); - - context('meta-tx', function () { - let followNFT: FollowNFT; - beforeEach(async function () { - await expect(lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - followNFT = FollowNFT__factory.connect(await lensHub.getFollowNFT(FIRST_PROFILE_ID), user); - }); - - context('negatives', function () { - it('TestWallet should fail to delegate with sig with signature deadline mismatch', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getDelegateBySigParts( - followNFT.address, - await followNFT.name(), - testWallet.address, - userAddress, - nonce, - '0' - ); - - await expect( - followNFT.delegateBySig(testWallet.address, userAddress, { - v, - r, - s, - deadline: MAX_UINT256, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to delegate with sig with invalid deadline', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getDelegateBySigParts( - followNFT.address, - await followNFT.name(), - testWallet.address, - userAddress, - nonce, - '0' - ); - - await expect( - followNFT.delegateBySig(testWallet.address, userAddress, { - v, - r, - s, - deadline: '0', - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('TestWallet should fail to delegate with sig with invalid nonce', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getDelegateBySigParts( - followNFT.address, - await followNFT.name(), - testWallet.address, - userAddress, - nonce + 1, - MAX_UINT256 - ); - - await expect( - followNFT.delegateBySig(testWallet.address, userAddress, { - v, - r, - s, - deadline: MAX_UINT256, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should sign attempt to delegate by sig, cancel with empty permitForAll, then fail to delegate by sig', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getDelegateBySigParts( - followNFT.address, - await followNFT.name(), - testWallet.address, - userAddress, - nonce, - MAX_UINT256 - ); - - await cancelWithPermitForAll(followNFT.address); - - await expect( - followNFT.delegateBySig(testWallet.address, userAddress, { - v, - r, - s, - deadline: MAX_UINT256, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should delegate by sig to user, governance power should be accurate before and after', async function () { - const nonce = (await lensHub.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getDelegateBySigParts( - followNFT.address, - await followNFT.name(), - testWallet.address, - userAddress, - nonce, - MAX_UINT256 - ); - - let blockNumber = await getBlockNumber(); - expect(await followNFT.getPowerByBlockNumber(userAddress, blockNumber)).to.eq(0); - expect(await followNFT.getPowerByBlockNumber(testWallet.address, blockNumber)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(blockNumber)).to.eq(0); - - await expect( - followNFT.delegateBySig(testWallet.address, userAddress, { - v, - r, - s, - deadline: MAX_UINT256, - }) - ).to.not.be.reverted; - - blockNumber = await getBlockNumber(); - expect(await followNFT.getPowerByBlockNumber(userAddress, blockNumber)).to.eq(1); - expect(await followNFT.getPowerByBlockNumber(testWallet.address, blockNumber)).to.eq(0); - expect(await followNFT.getDelegatedSupplyByBlockNumber(blockNumber)).to.eq(1); - }); - }); - }); -}); diff --git a/test/nft/lens-nft-base.spec.ts b/test/nft/lens-nft-base.spec.ts index c21ca66..60c897c 100644 --- a/test/nft/lens-nft-base.spec.ts +++ b/test/nft/lens-nft-base.spec.ts @@ -1,4 +1,5 @@ import '@nomiclabs/hardhat-ethers'; +import hre from 'hardhat'; import { expect } from 'chai'; import { keccak256, toUtf8Bytes } from 'ethers/lib/utils'; import { MAX_UINT256, ZERO_ADDRESS } from '../helpers/constants'; @@ -8,6 +9,7 @@ import { getBurnWithSigparts, getChainId, getPermitForAllParts, + getPermitMessageParts, getPermitParts, } from '../helpers/utils'; import { @@ -23,7 +25,16 @@ import { user, userAddress, } from '../__setup.spec'; +import { hardhatArguments } from 'hardhat'; +import { + BadMockEIP1271Implementer__factory, + MockEIP1271Implementer__factory, +} from '../../typechain-types'; +// TODO: This largely does not actually test the LensNFTBase contract, instead testing the +// modified versions of the functions found in the LensHub. This should be renamed to base LensHub +// functionality, and cloned, with the NFT being tested being a Collect/Follow NFT, because they +// don't override the base functionality. makeSuiteCleanRoom('Lens NFT Base Functionality', function () { context('generic', function () { it('Domain separator fetched from contract should be accurate', async function () { @@ -104,7 +115,7 @@ makeSuiteCleanRoom('Lens NFT Base Functionality', function () { s, deadline: MAX_UINT256, }) - ).to.be.revertedWith(ERRORS.ERC721_QUERY_FOR_NONEXISTENT_TOKEN); + ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); }); it('TestWallet should fail to permit with signature deadline mismatch', async function () { @@ -326,7 +337,7 @@ makeSuiteCleanRoom('Lens NFT Base Functionality', function () { ); await expect(lensHub.burnWithSig(0, { v, r, s, deadline: MAX_UINT256 })).to.be.revertedWith( - ERRORS.ERC721_QUERY_FOR_NONEXISTENT_TOKEN + ERRORS.SIGNATURE_INVALID ); }); @@ -395,6 +406,39 @@ makeSuiteCleanRoom('Lens NFT Base Functionality', function () { lensHub.burnWithSig(FIRST_PROFILE_ID, { v, r, s, deadline: MAX_UINT256 }) ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); }); + + it('TestWallet should deploy bad EIP1271 implementer, transfer NFT to it, sign message and permit user, permit should fail with invalid sig', async function () { + const sigContract = await new BadMockEIP1271Implementer__factory(testWallet).deploy(); + const nonce = (await lensHub.sigNonces(sigContract.address)).toNumber(); + await expect( + lensHub + .connect(testWallet) + .transferFrom(testWallet.address, sigContract.address, FIRST_PROFILE_ID) + ).to.not.be.reverted; + + const { v, r, s } = await getPermitMessageParts( + lensHub.address, + LENS_HUB_NFT_NAME, + userAddress, + FIRST_PROFILE_ID, + nonce, + MAX_UINT256 + ); + + await expect( + lensHub.permit( + userAddress, + FIRST_PROFILE_ID, + { + v, + r, + s, + deadline: MAX_UINT256, + }, + { gasLimit: 12450000 } + ) + ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); + }); }); context('Scenarios', function () { @@ -409,14 +453,18 @@ makeSuiteCleanRoom('Lens NFT Base Functionality', function () { nonce, MAX_UINT256 ); - await expect( - lensHub.permit(userAddress, FIRST_PROFILE_ID, { - v, - r, - s, - deadline: MAX_UINT256, - }) + lensHub.permit( + userAddress, + FIRST_PROFILE_ID, + { + v, + r, + s, + deadline: MAX_UINT256, + }, + { gasLimit: 12450000 } + ) ).to.not.be.reverted; await expect( @@ -480,6 +528,39 @@ makeSuiteCleanRoom('Lens NFT Base Functionality', function () { lensHub.connect(user).burnWithSig(FIRST_PROFILE_ID, { v, r, s, deadline: MAX_UINT256 }) ).to.not.be.reverted; }); + + it('TestWallet should deploy EIP1271 implementer, transfer NFT to it, sign message and permit user, user should transfer NFT, send back NFT and fail to transfer it again', async function () { + const sigContract = await new MockEIP1271Implementer__factory(testWallet).deploy(); + const nonce = (await lensHub.sigNonces(sigContract.address)).toNumber(); + await expect( + lensHub + .connect(testWallet) + .transferFrom(testWallet.address, sigContract.address, FIRST_PROFILE_ID) + ).to.not.be.reverted; + + const { v, r, s } = await getPermitMessageParts( + lensHub.address, + LENS_HUB_NFT_NAME, + userAddress, + FIRST_PROFILE_ID, + nonce, + MAX_UINT256 + ); + + await expect( + lensHub.permit( + userAddress, + FIRST_PROFILE_ID, + { + v, + r, + s, + deadline: MAX_UINT256, + }, + { gasLimit: 12450000 } + ) + ).to.not.be.reverted; + }); }); }); }); diff --git a/test/other/events.spec.ts b/test/other/events.spec.ts deleted file mode 100644 index 9860392..0000000 --- a/test/other/events.spec.ts +++ /dev/null @@ -1,690 +0,0 @@ -import { TransactionReceipt } from '@ethersproject/providers'; -import '@nomiclabs/hardhat-ethers'; -import { expect } from 'chai'; -import { TransparentUpgradeableProxy__factory } from '../../typechain-types'; -import { MAX_UINT256, ZERO_ADDRESS } from '../helpers/constants'; -import { - getAbbreviation, - getTimestamp, - matchEvent, - ProtocolState, - waitForTx, -} from '../helpers/utils'; -import { - approvalFollowModule, - deployer, - deployerAddress, - freeCollectModule, - FIRST_PROFILE_ID, - governance, - governanceAddress, - lensHub, - lensHubImpl, - LENS_HUB_NFT_NAME, - LENS_HUB_NFT_SYMBOL, - makeSuiteCleanRoom, - MOCK_FOLLOW_NFT_URI, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - MOCK_URI, - moduleGlobals, - treasuryAddress, - TREASURY_FEE_BPS, - user, - userAddress, - userTwo, - userTwoAddress, - abiCoder, - feeCollectModule, - currency, -} from '../__setup.spec'; - -/** - * Note: We use the `lensHubImpl` contract to test ERC721 specific events. - * - * TODO: Add specific test cases to ensure all module encoded return data parameters are - * as expected. - * - * TODO: Add module deployment tests. - */ -makeSuiteCleanRoom('Events', function () { - let receipt: TransactionReceipt; - - context('Misc', function () { - it('Proxy initialization should emit expected events', async function () { - let data = lensHubImpl.interface.encodeFunctionData('initialize', [ - LENS_HUB_NFT_NAME, - LENS_HUB_NFT_SYMBOL, - governanceAddress, - ]); - - let proxy = await new TransparentUpgradeableProxy__factory(deployer).deploy( - lensHubImpl.address, - deployerAddress, - data - ); - - receipt = await waitForTx(proxy.deployTransaction, true); - - expect(receipt.logs.length).to.eq(5); - matchEvent(receipt, 'Upgraded', [lensHubImpl.address], proxy); - matchEvent(receipt, 'AdminChanged', [ZERO_ADDRESS, deployerAddress], proxy); - matchEvent(receipt, 'GovernanceSet', [ - deployerAddress, - ZERO_ADDRESS, - governanceAddress, - await getTimestamp(), - ]); - matchEvent(receipt, 'StateSet', [ - deployerAddress, - ProtocolState.Unpaused, - ProtocolState.Paused, - await getTimestamp(), - ]); - matchEvent(receipt, 'BaseInitialized', [ - LENS_HUB_NFT_NAME, - LENS_HUB_NFT_SYMBOL, - await getTimestamp(), - ]); - }); - }); - - context('Hub Governance', function () { - it('Governance change should emit expected event', async function () { - receipt = await waitForTx(lensHub.connect(governance).setGovernance(userAddress)); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'GovernanceSet', [ - governanceAddress, - governanceAddress, - userAddress, - await getTimestamp(), - ]); - }); - - it('Emergency admin change should emit expected event', async function () { - receipt = await waitForTx(lensHub.connect(governance).setEmergencyAdmin(userAddress)); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'EmergencyAdminSet', [ - governanceAddress, - ZERO_ADDRESS, - userAddress, - await getTimestamp(), - ]); - }); - - it('Protocol state change by governance should emit expected event', async function () { - receipt = await waitForTx(lensHub.connect(governance).setState(ProtocolState.Paused)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'StateSet', [ - governanceAddress, - ProtocolState.Unpaused, - ProtocolState.Paused, - await getTimestamp(), - ]); - - receipt = await waitForTx( - lensHub.connect(governance).setState(ProtocolState.PublishingPaused) - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'StateSet', [ - governanceAddress, - ProtocolState.Paused, - ProtocolState.PublishingPaused, - await getTimestamp(), - ]); - - receipt = await waitForTx(lensHub.connect(governance).setState(ProtocolState.Unpaused)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'StateSet', [ - governanceAddress, - ProtocolState.PublishingPaused, - ProtocolState.Unpaused, - await getTimestamp(), - ]); - }); - - it('Protocol state change by emergency admin should emit expected events', async function () { - await waitForTx(lensHub.connect(governance).setEmergencyAdmin(userAddress)); - - receipt = await waitForTx(lensHub.connect(user).setState(ProtocolState.PublishingPaused)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'StateSet', [ - userAddress, - ProtocolState.Unpaused, - ProtocolState.PublishingPaused, - await getTimestamp(), - ]); - - receipt = await waitForTx(lensHub.connect(user).setState(ProtocolState.Paused)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'StateSet', [ - userAddress, - ProtocolState.PublishingPaused, - ProtocolState.Paused, - await getTimestamp(), - ]); - }); - - it('Follow module whitelisting functions should emit expected event', async function () { - receipt = await waitForTx( - lensHub.connect(governance).whitelistFollowModule(userAddress, true) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleWhitelisted', [userAddress, true, await getTimestamp()]); - - receipt = await waitForTx( - lensHub.connect(governance).whitelistFollowModule(userAddress, false) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleWhitelisted', [userAddress, false, await getTimestamp()]); - }); - - it('Reference module whitelisting functions should emit expected event', async function () { - receipt = await waitForTx( - lensHub.connect(governance).whitelistReferenceModule(userAddress, true) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ReferenceModuleWhitelisted', [userAddress, true, await getTimestamp()]); - - receipt = await waitForTx( - lensHub.connect(governance).whitelistReferenceModule(userAddress, false) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ReferenceModuleWhitelisted', [userAddress, false, await getTimestamp()]); - }); - - it('Collect module whitelisting functions should emit expected event', async function () { - receipt = await waitForTx( - lensHub.connect(governance).whitelistCollectModule(userAddress, true) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'CollectModuleWhitelisted', [userAddress, true, await getTimestamp()]); - - receipt = await waitForTx( - lensHub.connect(governance).whitelistCollectModule(userAddress, false) - ); - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'CollectModuleWhitelisted', [userAddress, false, await getTimestamp()]); - }); - }); - - context('Hub Interaction', function () { - async function createProfile() { - await waitForTx( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ); - } - - it('Profile creation for other user should emit the correct events', async function () { - receipt = await waitForTx( - lensHub.createProfile({ - to: userTwoAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ); - - expect(receipt.logs.length).to.eq(2); - matchEvent( - receipt, - 'Transfer', - [ZERO_ADDRESS, userTwoAddress, FIRST_PROFILE_ID], - lensHubImpl - ); - matchEvent(receipt, 'ProfileCreated', [ - FIRST_PROFILE_ID, - userAddress, - userTwoAddress, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - ZERO_ADDRESS, - [], - MOCK_FOLLOW_NFT_URI, - await getTimestamp(), - ]); - }); - - it('Profile creation should emit the correct events', async function () { - receipt = await waitForTx( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ); - - expect(receipt.logs.length).to.eq(2); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userAddress, FIRST_PROFILE_ID], lensHubImpl); - matchEvent(receipt, 'ProfileCreated', [ - FIRST_PROFILE_ID, - userAddress, - userAddress, - MOCK_PROFILE_HANDLE, - MOCK_PROFILE_URI, - ZERO_ADDRESS, - [], - MOCK_FOLLOW_NFT_URI, - await getTimestamp(), - ]); - }); - - it('Setting follow module should emit correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistFollowModule(approvalFollowModule.address, true) - ); - - receipt = await waitForTx( - lensHub.setFollowModule(FIRST_PROFILE_ID, approvalFollowModule.address, []) - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'FollowModuleSet', [ - FIRST_PROFILE_ID, - approvalFollowModule.address, - [], - await getTimestamp(), - ]); - }); - - it('Setting dispatcher should emit correct events', async function () { - await createProfile(); - - receipt = await waitForTx(lensHub.setDispatcher(FIRST_PROFILE_ID, userAddress)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'DispatcherSet', [FIRST_PROFILE_ID, userAddress, await getTimestamp()]); - }); - - it('Posting should emit the correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ); - - receipt = await waitForTx( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'PostCreated', [ - FIRST_PROFILE_ID, - 1, - MOCK_URI, - freeCollectModule.address, - abiCoder.encode(['bool'], [true]), - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('Commenting should emit the correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ); - await waitForTx( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - receipt = await waitForTx( - lensHub.comment({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - expect(receipt.logs.length).to.eq(1); - - matchEvent(receipt, 'CommentCreated', [ - FIRST_PROFILE_ID, - 2, - MOCK_URI, - FIRST_PROFILE_ID, - 1, - [], - freeCollectModule.address, - abiCoder.encode(['bool'], [true]), - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('Mirroring should emit the correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ); - await waitForTx( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: freeCollectModule.address, - collectModuleInitData: abiCoder.encode(['bool'], [true]), - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - receipt = await waitForTx( - lensHub.mirror({ - profileId: FIRST_PROFILE_ID, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - expect(receipt.logs.length).to.eq(1); - - matchEvent(receipt, 'MirrorCreated', [ - FIRST_PROFILE_ID, - 2, - FIRST_PROFILE_ID, - 1, - [], - ZERO_ADDRESS, - [], - await getTimestamp(), - ]); - }); - - it('Following should emit correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(freeCollectModule.address, true) - ); - - const mockData = abiCoder.encode(['uint256'], [123]); - receipt = await waitForTx(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [mockData])); - const followNFT = await lensHub.getFollowNFT(FIRST_PROFILE_ID); - - const expectedName = MOCK_PROFILE_HANDLE + '-Follower'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Fl'; - - expect(receipt.logs.length).to.eq(5); - matchEvent(receipt, 'FollowNFTDeployed', [FIRST_PROFILE_ID, followNFT, await getTimestamp()]); - matchEvent(receipt, 'Followed', [ - userTwoAddress, - [FIRST_PROFILE_ID], - [mockData], - await getTimestamp(), - ]); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userTwoAddress, 1], lensHubImpl); - matchEvent(receipt, 'FollowNFTTransferred', [ - FIRST_PROFILE_ID, - 1, - ZERO_ADDRESS, - userTwoAddress, - await getTimestamp(), - ]); - }); - - it('Collecting should emit correct events', async function () { - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(feeCollectModule.address, true) - ); - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - - const collectPrice = 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [collectPrice, currency.address, userAddress, 0, true] - ); - await waitForTx( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - await waitForTx(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])); - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const collectData = abiCoder.encode(['address', 'uint256'], [currency.address, collectPrice]); - receipt = await waitForTx(lensHub.connect(userTwo).collect(FIRST_PROFILE_ID, 1, collectData)); - const collectNFT = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - - expect(receipt.logs.length).to.eq(7); - matchEvent(receipt, 'CollectNFTDeployed', [ - FIRST_PROFILE_ID, - 1, - collectNFT, - await getTimestamp(), - ]); - matchEvent(receipt, 'Collected', [ - userTwoAddress, - FIRST_PROFILE_ID, - 1, - FIRST_PROFILE_ID, - 1, - collectData, - await getTimestamp(), - ]); - matchEvent(receipt, 'BaseInitialized', [expectedName, expectedSymbol, await getTimestamp()]); - matchEvent(receipt, 'CollectNFTInitialized', [FIRST_PROFILE_ID, 1, await getTimestamp()]); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userTwoAddress, 1], lensHubImpl); - matchEvent(receipt, 'CollectNFTTransferred', [ - FIRST_PROFILE_ID, - 1, - 1, - ZERO_ADDRESS, - userTwoAddress, - await getTimestamp(), - ]); - }); - - it('Collecting from a mirror should emit correct events', async function () { - const secondProfileId = FIRST_PROFILE_ID + 1; - await createProfile(); - - await waitForTx( - lensHub.connect(governance).whitelistCollectModule(feeCollectModule.address, true) - ); - await expect( - moduleGlobals.connect(governance).whitelistCurrency(currency.address, true) - ).to.not.be.reverted; - - const collectPrice = 1; - const collectModuleInitData = abiCoder.encode( - ['uint256', 'address', 'address', 'uint16', 'bool'], - [collectPrice, currency.address, userAddress, 0, true] - ); - await waitForTx( - lensHub.post({ - profileId: FIRST_PROFILE_ID, - contentURI: MOCK_URI, - collectModule: feeCollectModule.address, - collectModuleInitData: collectModuleInitData, - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - await waitForTx(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])); - - await waitForTx( - lensHub.connect(userTwo).createProfile({ - to: userTwoAddress, - handle: 'usertwo', - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ); - - await waitForTx( - lensHub.connect(userTwo).mirror({ - profileId: secondProfileId, - profileIdPointed: FIRST_PROFILE_ID, - pubIdPointed: 1, - referenceModuleData: [], - referenceModule: ZERO_ADDRESS, - referenceModuleInitData: [], - }) - ); - - await expect(currency.mint(userTwoAddress, MAX_UINT256)).to.not.be.reverted; - await expect( - currency.connect(userTwo).approve(feeCollectModule.address, MAX_UINT256) - ).to.not.be.reverted; - const collectData = abiCoder.encode(['address', 'uint256'], [currency.address, collectPrice]); - - receipt = await waitForTx(lensHub.connect(userTwo).collect(secondProfileId, 1, collectData)); - const collectNFT = await lensHub.getCollectNFT(FIRST_PROFILE_ID, 1); - const expectedName = MOCK_PROFILE_HANDLE + '-Collect-' + '1'; - const expectedSymbol = getAbbreviation(MOCK_PROFILE_HANDLE) + '-Cl-' + '1'; - - expect(receipt.logs.length).to.eq(7); - matchEvent(receipt, 'CollectNFTDeployed', [ - FIRST_PROFILE_ID, - 1, - collectNFT, - await getTimestamp(), - ]); - matchEvent(receipt, 'Collected', [ - userTwoAddress, - secondProfileId, - 1, - FIRST_PROFILE_ID, - 1, - collectData, - await getTimestamp(), - ]); - matchEvent(receipt, 'BaseInitialized', [expectedName, expectedSymbol, await getTimestamp()]); - matchEvent(receipt, 'CollectNFTInitialized', [FIRST_PROFILE_ID, 1, await getTimestamp()]); - matchEvent(receipt, 'Transfer', [ZERO_ADDRESS, userTwoAddress, 1], lensHubImpl); - matchEvent(receipt, 'CollectNFTTransferred', [ - FIRST_PROFILE_ID, - 1, - 1, - ZERO_ADDRESS, - userTwoAddress, - await getTimestamp(), - ]); - }); - }); - - context('Module Globals Governance', function () { - it('Governance change should emit expected event', async function () { - receipt = await waitForTx(moduleGlobals.connect(governance).setGovernance(userAddress)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ModuleGlobalsGovernanceSet', [ - governanceAddress, - userAddress, - await getTimestamp(), - ]); - }); - - it('Treasury change should emit expected event', async function () { - receipt = await waitForTx(moduleGlobals.connect(governance).setTreasury(userAddress)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ModuleGlobalsTreasurySet', [ - treasuryAddress, - userAddress, - await getTimestamp(), - ]); - }); - - it('Treasury fee change should emit expected event', async function () { - receipt = await waitForTx(moduleGlobals.connect(governance).setTreasuryFee(123)); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ModuleGlobalsTreasuryFeeSet', [ - TREASURY_FEE_BPS, - 123, - await getTimestamp(), - ]); - }); - - it('Currency whitelisting should emit expected event', async function () { - receipt = await waitForTx( - moduleGlobals.connect(governance).whitelistCurrency(userAddress, true) - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ModuleGlobalsCurrencyWhitelisted', [ - userAddress, - false, - true, - await getTimestamp(), - ]); - - receipt = await waitForTx( - moduleGlobals.connect(governance).whitelistCurrency(userAddress, false) - ); - - expect(receipt.logs.length).to.eq(1); - matchEvent(receipt, 'ModuleGlobalsCurrencyWhitelisted', [ - userAddress, - true, - false, - await getTimestamp(), - ]); - }); - }); -}); diff --git a/test/other/misc.spec.ts b/test/other/misc.spec.ts index 2f70399..59719b8 100644 --- a/test/other/misc.spec.ts +++ b/test/other/misc.spec.ts @@ -45,6 +45,7 @@ import { lensPeriphery, followNFTImpl, collectNFTImpl, + userThreeAddress, } from '../__setup.spec'; /** @@ -99,7 +100,7 @@ makeSuiteCleanRoom('Misc', function () { expect(await lensHub.getGovernance()).to.eq(governanceAddress); }); - it('Profile handle getter should return the correct handle', async function () { + it.skip('Profile handle getter should return the correct handle', async function () { expect(await lensHub.getHandle(FIRST_PROFILE_ID)).to.eq(MOCK_PROFILE_HANDLE); }); @@ -125,10 +126,10 @@ makeSuiteCleanRoom('Misc', function () { expect(await lensHub.getDispatcher(FIRST_PROFILE_ID)).to.eq(ZERO_ADDRESS); }); - it('Profile follow NFT getter should return the zero address before the first follow, then the correct address afterwards', async function () { + it.skip('Profile follow NFT getter should return the zero address before the first follow, then the correct address afterwards', async function () { expect(await lensHub.getFollowNFT(FIRST_PROFILE_ID)).to.eq(ZERO_ADDRESS); - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; expect(await lensHub.getFollowNFT(FIRST_PROFILE_ID)).to.not.eq(ZERO_ADDRESS); }); @@ -177,7 +178,7 @@ makeSuiteCleanRoom('Misc', function () { expect(await lensHub.getCollectNFTImpl()).to.eq(collectNFTImpl.address); }); - it('Profile tokenURI should return the accurate URI', async function () { + it.skip('Profile tokenURI should return the accurate URI', async function () { const tokenUri = await lensHub.tokenURI(FIRST_PROFILE_ID); const metadata = await getMetadataFromBase64TokenUri(tokenUri); expect(metadata.name).to.eq(`@${MOCK_PROFILE_HANDLE}`); @@ -544,13 +545,13 @@ makeSuiteCleanRoom('Misc', function () { it('Profile getter should return accurate profile parameters', async function () { const fetchedProfile = await lensHub.getProfile(FIRST_PROFILE_ID); expect(fetchedProfile.pubCount).to.eq(0); - expect(fetchedProfile.handle).to.eq(MOCK_PROFILE_HANDLE); + // expect(fetchedProfile.handle).to.eq(MOCK_PROFILE_HANDLE); expect(fetchedProfile.followModule).to.eq(ZERO_ADDRESS); expect(fetchedProfile.followNFT).to.eq(ZERO_ADDRESS); }); }); - context('Follow Module Misc', function () { + context.skip('Follow Module Misc', function () { beforeEach(async function () { await expect( lensHub.connect(governance).whitelistFollowModule(approvalFollowModule.address, true) @@ -569,14 +570,14 @@ makeSuiteCleanRoom('Misc', function () { }); it('User should fail to call processFollow directly on a follow module inheriting from the FollowValidatorFollowModuleBase', async function () { - await expect(approvalFollowModule.processFollow(ZERO_ADDRESS, 0, [])).to.be.revertedWith( - ERRORS.NOT_HUB - ); + await expect( + approvalFollowModule.processFollow(0, ZERO_ADDRESS, userAddress, 0, []) + ).to.be.revertedWith(ERRORS.NOT_HUB); }); it('Follow module following check when there are no follows, and thus no deployed Follow NFT should return false', async function () { expect( - await approvalFollowModule.isFollowing(FIRST_PROFILE_ID, userTwoAddress, 0) + await approvalFollowModule.isFollowing(0, FIRST_PROFILE_ID, userTwoAddress, 0) ).to.be.false; }); @@ -584,10 +585,10 @@ makeSuiteCleanRoom('Misc', function () { await expect( approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userAddress], [true]) ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; expect( - await approvalFollowModule.isFollowing(FIRST_PROFILE_ID, userTwoAddress, 0) + await approvalFollowModule.isFollowing(0, FIRST_PROFILE_ID, userTwoAddress, 0) ).to.be.false; }); @@ -595,21 +596,21 @@ makeSuiteCleanRoom('Misc', function () { await expect( approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userAddress], [true]) ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; await expect( - approvalFollowModule.isFollowing(FIRST_PROFILE_ID, userAddress, 2) - ).to.be.revertedWith(ERRORS.ERC721_QUERY_FOR_NONEXISTENT_TOKEN); + approvalFollowModule.isFollowing(0, FIRST_PROFILE_ID, userAddress, 2) + ).to.be.revertedWith('0xc5e76061'); // This is the selector for "ERC721Time_OwnerQueryForNonexistantToken()" }); it('Follow module following check with specific ID input should return false if another address owns the specified follow NFT', async function () { await expect( approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userAddress], [true]) ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; expect( - await approvalFollowModule.isFollowing(FIRST_PROFILE_ID, userTwoAddress, 1) + await approvalFollowModule.isFollowing(0, FIRST_PROFILE_ID, userTwoAddress, 1) ).to.be.false; }); @@ -617,16 +618,18 @@ makeSuiteCleanRoom('Misc', function () { await expect( approvalFollowModule.connect(user).approve(FIRST_PROFILE_ID, [userAddress], [true]) ).to.not.be.reverted; - await expect(lensHub.follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; + await expect(lensHub.follow(userAddress, [FIRST_PROFILE_ID], [[]])).to.not.be.reverted; - expect(await approvalFollowModule.isFollowing(FIRST_PROFILE_ID, userAddress, 1)).to.be.true; + expect( + await approvalFollowModule.isFollowing(0, FIRST_PROFILE_ID, userAddress, 1) + ).to.be.true; }); }); context('Collect Module Misc', function () { it('Should fail to call processCollect directly on a collect module inheriting from the FollowValidationModuleBase contract', async function () { await expect( - timedFeeCollectModule.processCollect(0, ZERO_ADDRESS, 0, 0, []) + timedFeeCollectModule.processCollect(0, 0, ZERO_ADDRESS, userAddress, 0, 0, []) ).to.be.revertedWith(ERRORS.NOT_HUB); }); }); @@ -687,7 +690,7 @@ makeSuiteCleanRoom('Misc', function () { }); }); - context('UI Data Provider', function () { + context.skip('UI Data Provider', function () { it('UI Data Provider should return expected values', async function () { // First, create a profile, await expect( @@ -774,7 +777,7 @@ makeSuiteCleanRoom('Misc', function () { }); }); - context('LensPeriphery', async function () { + context.skip('LensPeriphery', async function () { context('ToggleFollowing', function () { beforeEach(async function () { await expect( @@ -787,12 +790,14 @@ makeSuiteCleanRoom('Misc', function () { followNFTURI: MOCK_FOLLOW_NFT_URI, }) ).to.not.be.reverted; - await expect(lensHub.connect(userTwo).follow([FIRST_PROFILE_ID], [[]])).to.not.be.reverted; await expect( - lensHub.connect(userThree).follow([FIRST_PROFILE_ID], [[]]) + lensHub.connect(userTwo).follow(userTwoAddress, [FIRST_PROFILE_ID], [[]]) ).to.not.be.reverted; await expect( - lensHub.connect(testWallet).follow([FIRST_PROFILE_ID], [[]]) + lensHub.connect(userThree).follow(userThreeAddress, [FIRST_PROFILE_ID], [[]]) + ).to.not.be.reverted; + await expect( + lensHub.connect(testWallet).follow(testWallet.address, [FIRST_PROFILE_ID], [[]]) ).to.not.be.reverted; }); @@ -858,7 +863,7 @@ makeSuiteCleanRoom('Misc', function () { }) ).to.not.be.reverted; await expect( - lensHub.connect(userTwo).follow([FIRST_PROFILE_ID + 1], [[]]) + lensHub.connect(userTwo).follow(userTwoAddress, [FIRST_PROFILE_ID + 1], [[]]) ).to.not.be.reverted; const tx = lensPeriphery @@ -1062,194 +1067,5 @@ makeSuiteCleanRoom('Misc', function () { }); }); }); - - context('Profile Metadata URI', function () { - const MOCK_DATA = 'd171c8b1d364bb34553299ab686caa41ac7a2209d4a63e25947764080c4681da'; - - context('Generic', function () { - beforeEach(async function () { - await expect( - lensHub.createProfile({ - to: userAddress, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - context('Negatives', function () { - it('User two should fail to set profile metadata URI for a profile that is not theirs while they are not the dispatcher', async function () { - await expect( - lensPeriphery.connect(userTwo).setProfileMetadataURI(FIRST_PROFILE_ID, MOCK_DATA) - ).to.be.revertedWith(ERRORS.NOT_PROFILE_OWNER_OR_DISPATCHER); - }); - }); - - context('Scenarios', function () { - it("User should set user two as dispatcher, user two should set profile metadata URI for user one's profile, fetched data should be accurate", async function () { - await expect( - lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress) - ).to.not.be.reverted; - await expect( - lensPeriphery.connect(userTwo).setProfileMetadataURI(FIRST_PROFILE_ID, MOCK_DATA) - ).to.not.be.reverted; - - expect(await lensPeriphery.getProfileMetadataURI(FIRST_PROFILE_ID)).to.eq(MOCK_DATA); - expect(await lensPeriphery.getProfileMetadataURI(FIRST_PROFILE_ID)).to.eq(MOCK_DATA); - }); - - it('Setting profile metadata should emit the correct event', async function () { - const tx = await waitForTx( - lensPeriphery.setProfileMetadataURI(FIRST_PROFILE_ID, MOCK_DATA) - ); - - matchEvent(tx, 'ProfileMetadataSet', [ - FIRST_PROFILE_ID, - MOCK_DATA, - await getTimestamp(), - ]); - }); - - it('Setting profile metadata via dispatcher should emit the correct event', async function () { - await expect( - lensHub.setDispatcher(FIRST_PROFILE_ID, userTwoAddress) - ).to.not.be.reverted; - - const tx = await waitForTx( - lensPeriphery.connect(userTwo).setProfileMetadataURI(FIRST_PROFILE_ID, MOCK_DATA) - ); - - matchEvent(tx, 'ProfileMetadataSet', [ - FIRST_PROFILE_ID, - MOCK_DATA, - await getTimestamp(), - ]); - }); - }); - }); - - context('Meta-tx', async function () { - beforeEach(async function () { - await expect( - lensHub.connect(testWallet).createProfile({ - to: testWallet.address, - handle: MOCK_PROFILE_HANDLE, - imageURI: MOCK_PROFILE_URI, - followModule: ZERO_ADDRESS, - followModuleInitData: [], - followNFTURI: MOCK_FOLLOW_NFT_URI, - }) - ).to.not.be.reverted; - }); - - context('Negatives', async function () { - it('TestWallet should fail to set profile metadata URI with sig with signature deadline mismatch', async function () { - const nonce = (await lensPeriphery.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetProfileMetadataURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_DATA, - nonce, - '0' - ); - await expect( - lensPeriphery.setProfileMetadataURIWithSig({ - profileId: FIRST_PROFILE_ID, - metadata: MOCK_DATA, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - - it('TestWallet should fail to set profile metadata URI with sig with invalid deadline', async function () { - const nonce = (await lensPeriphery.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetProfileMetadataURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_DATA, - nonce, - '0' - ); - await expect( - lensPeriphery.setProfileMetadataURIWithSig({ - profileId: FIRST_PROFILE_ID, - metadata: MOCK_DATA, - sig: { - v, - r, - s, - deadline: '0', - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_EXPIRED); - }); - - it('TestWallet should fail to set profile metadata URI with sig with invalid nonce', async function () { - const nonce = (await lensPeriphery.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetProfileMetadataURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_DATA, - nonce + 1, - MAX_UINT256 - ); - await expect( - lensPeriphery.setProfileMetadataURIWithSig({ - profileId: FIRST_PROFILE_ID, - metadata: MOCK_DATA, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ).to.be.revertedWith(ERRORS.SIGNATURE_INVALID); - }); - }); - - context('Scenarios', function () { - it('TestWallet should set profile metadata URI with sig, fetched data should be accurate and correct event should be emitted', async function () { - const nonce = (await lensPeriphery.sigNonces(testWallet.address)).toNumber(); - - const { v, r, s } = await getSetProfileMetadataURIWithSigParts( - FIRST_PROFILE_ID, - MOCK_DATA, - nonce, - MAX_UINT256 - ); - const tx = await waitForTx( - lensPeriphery.setProfileMetadataURIWithSig({ - profileId: FIRST_PROFILE_ID, - metadata: MOCK_DATA, - sig: { - v, - r, - s, - deadline: MAX_UINT256, - }, - }) - ); - - expect(await lensPeriphery.getProfileMetadataURI(FIRST_PROFILE_ID)).to.eq(MOCK_DATA); - expect(await lensPeriphery.getProfileMetadataURI(FIRST_PROFILE_ID)).to.eq(MOCK_DATA); - - matchEvent(tx, 'ProfileMetadataSet', [ - FIRST_PROFILE_ID, - MOCK_DATA, - await getTimestamp(), - ]); - }); - }); - }); - }); }); }); diff --git a/test/other/mock-profile-creation-proxy.spec.ts b/test/other/mock-profile-creation-proxy.spec.ts index 3dc3981..3ff2f36 100644 --- a/test/other/mock-profile-creation-proxy.spec.ts +++ b/test/other/mock-profile-creation-proxy.spec.ts @@ -33,7 +33,7 @@ makeSuiteCleanRoom('Mock Profile Creation Proxy', function () { ).to.not.be.reverted; }); - context('Negatives', function () { + context.skip('Negatives', function () { it('Should fail to create profile if handle length before suffix does not reach minimum length', async function () { const handle = 'a'.repeat(MINIMUM_LENGTH - 1); await expect( @@ -97,7 +97,7 @@ makeSuiteCleanRoom('Mock Profile Creation Proxy', function () { }); }); - context('Scenarios', function () { + context.skip('Scenarios', function () { it('Should be able to create a profile using the whitelisted proxy, received NFT should be valid', async function () { let timestamp: any; let owner: string; diff --git a/test/other/profile-creation-proxy.spec.ts b/test/other/profile-creation-proxy.spec.ts index f3ad932..fbb8c36 100644 --- a/test/other/profile-creation-proxy.spec.ts +++ b/test/other/profile-creation-proxy.spec.ts @@ -34,7 +34,7 @@ makeSuiteCleanRoom('Profile Creation Proxy', function () { ).to.not.be.reverted; }); - context('Negatives', function () { + context.skip('Negatives', function () { it('Should fail to create profile if handle length before suffix does not reach minimum length', async function () { const handle = 'a'.repeat(MINIMUM_LENGTH - 1); await expect( @@ -98,7 +98,7 @@ makeSuiteCleanRoom('Profile Creation Proxy', function () { }); }); - context('Scenarios', function () { + context.skip('Scenarios', function () { it('Should be able to create a profile using the whitelisted proxy, received NFT should be valid', async function () { let timestamp: any; let owner: string; diff --git a/test/other/upgradeability.spec.ts b/test/other/upgradeability.spec.ts index f78486f..1812c49 100644 --- a/test/other/upgradeability.spec.ts +++ b/test/other/upgradeability.spec.ts @@ -1,5 +1,7 @@ import '@nomiclabs/hardhat-ethers'; +import hre from 'hardhat'; import { expect } from 'chai'; +import { BigNumber, BigNumberish } from 'ethers'; import { ethers } from 'hardhat'; import { MockLensHubV2BadRevision__factory, @@ -11,6 +13,7 @@ import { abiCoder, deployer, lensHub, makeSuiteCleanRoom, user } from '../__setu makeSuiteCleanRoom('Upgradeability', function () { const valueToSet = 123; + const totalSlotsUsed = 27; // Slots 0-26 are used. it('Should fail to initialize an implementation with the same revision', async function () { const newImpl = await new MockLensHubV2BadRevision__factory(deployer).deploy(); @@ -20,34 +23,36 @@ makeSuiteCleanRoom('Upgradeability', function () { await expect(hub.initialize(valueToSet)).to.be.revertedWith(ERRORS.INITIALIZED); }); - // The LensHub contract's last storage variable by default is at the 23nd slot (index 22) and contains the emergency admin - // We're going to validate the first 23 slots and the 24rd slot before and after the change - it("Should upgrade and set a new variable's value, previous storage is unchanged, new value is accurate", async function () { + // This validates that adding a storage slot works as expected. + it.skip("Should upgrade and set a new variable's value, previous storage is unchanged, new value is accurate", async function () { + const getStorageAt = ethers.provider.getStorageAt; const newImpl = await new MockLensHubV2__factory(deployer).deploy(); const proxyHub = TransparentUpgradeableProxy__factory.connect(lensHub.address, deployer); let prevStorage: string[] = []; - for (let i = 0; i < 24; i++) { - const valueAt = await ethers.provider.getStorageAt(proxyHub.address, i); + for (let i = 0; i < totalSlotsUsed; ++i) { + const valueAt = await getStorageAt(proxyHub.address, i); prevStorage.push(valueAt); } - - let prevNextSlot = await ethers.provider.getStorageAt(proxyHub.address, 24); - const formattedZero = abiCoder.encode(['uint256'], [0]); - expect(prevNextSlot).to.eq(formattedZero); + let prevNextSlot = await getStorageAt(proxyHub.address, totalSlotsUsed); + expect(prevNextSlot).to.eq(encodeUint(0)); await proxyHub.upgradeTo(newImpl.address); await expect( MockLensHubV2__factory.connect(proxyHub.address, user).setAdditionalValue(valueToSet) ).to.not.be.reverted; - for (let i = 0; i < 24; i++) { - const valueAt = await ethers.provider.getStorageAt(proxyHub.address, i); + for (let i = 0; i < totalSlotsUsed; ++i) { + const valueAt = await getStorageAt(proxyHub.address, i); expect(valueAt).to.eq(prevStorage[i]); } - const newNextSlot = await ethers.provider.getStorageAt(proxyHub.address, 24); - const formattedValue = abiCoder.encode(['uint256'], [valueToSet]); - expect(newNextSlot).to.eq(formattedValue); + const newNextSlot = await getStorageAt(proxyHub.address, totalSlotsUsed); + + expect(newNextSlot).to.eq(encodeUint(valueToSet)); }); + + function encodeUint(num: BigNumberish): string { + return abiCoder.encode(['uint256'], [num]); + } }); diff --git a/verifyStorageSlots.sh b/verifyStorageSlots.sh new file mode 100644 index 0000000..63dc758 --- /dev/null +++ b/verifyStorageSlots.sh @@ -0,0 +1,73 @@ +# This script compares the Storage Layout differences before/after the upgrade ("old"/"new" implementations). +# The address of previous implentation if fetched from TransparentProxy "implementation()" slot. +# The previous implementation source code is fetched from the block explorer. +# New implementation is assumed to be in the current repo +# Storage Layouts are generated from both implementations and compared using diff +# (It is normal for the numbers in end of type names to be different) +source .env + +if [[ $1 == "" ]] + then + echo "Usage:" + echo " verifyStorageSlots.sh [network] [contractName]" + echo " e.g. network (required): polygon or mumbai" + echo " e.g. contractName (optional): LensHub is default" + echo "" + echo "Example:" + echo " verifyStorageSlots.sh polygon LensHub" + exit 1 +fi + +# TransparentUpgradeableProxy implementation slot +implementationSlot="0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc" + +if [[ $2 != "" ]] + then + contractName=$2 + else + contractName="LensHub" +fi + +case $1 in + 'polygon' | 'matic') + echo "Network: Polygon mainnet" + rpcUrl=$POLYGON_RPC_URL + proxyAddress=$LENS_HUB_POLYGON + blockexplorerKey=$POLYGONSCAN_MAINNET_KEY + chain='polygon' + ;; + 'mumbai') + echo "Network: Polygon mainnet" + rpcUrl=$MUMBAI_RPC_URL + proxyAddress=$LENS_HUB_MUMBAI + blockexplorerKey=$POLYGONSCAN_MUMBAI_KEY + chain='mumbai' + ;; + *) + echo "ERROR: Unsupported network" + exit 1 + ;; +esac + +echo "Proxy address:" $proxyAddress +echo "Contract name:" $contractName + +# Fetching the old implementation address +rawOldImplAddress=$(cast storage $proxyAddress $implementationSlot --rpc-url $rpcUrl) +oldImplAddress="0x${rawOldImplAddress:(-40)}" +echo "Old Implementation address: $oldImplAddress" + +# Fetching the old implementation source code and saving it to oldImpl folder +rm -rf oldImpl +cast etherscan-source -d oldImpl $oldImplAddress --chain $chain --etherscan-api-key $blockexplorerKey +echo "Old Implementation code saved to ./oldImpl/" + +# Generating the Storage Layout JSON of the old implementation +echo "Generating the Storage Layout JSON of the old implementation..." +forge inspect $contractName storage --contracts oldImpl > oldImplStorageLayout.json + +# Generating the Storage Layout JSON of the new implementation +echo "Generating the Storage Layout JSON of the new implementation..." +forge inspect $contractName storage > newImplStorageLayout.json + +diff <(awk '/astId/{next} /"types"/{found=0} {if(found) print} /"storage"/{found=1}' oldImplStorageLayout.json) <(awk '/astId/{next} /"types"/{found=0} {if(found) print} /"storage"/{found=1}' newImplStorageLayout.json) -c