prepare new e2e test for getSellerByAddress() (deactivated for now)

Author: levalleux-ludo

contracts/scripts/deploy.js

@@ -168,6 +168,19 @@ async function main() {
     config[0].token = mockBosonToken.address;
   }
 
+  if (hre.network.name === "localhost") {
+    console.log(`\n💎 Deploying mock LENS contract...`);
+    const confirmations = 1;
+    let lensTokenContractFactory = await ethers.getContractFactory(
+      "MockNFTAuth721"
+    );
+    const lensTokenContract = await lensTokenContractFactory.deploy({
+      gasLimit
+    });
+    await lensTokenContract.deployTransaction.wait(confirmations);
+    deploymentComplete("LensToken", lensTokenContract.address, [], contracts);
+  }
+
   console.log(
     `\n💎 Deploying AccessController, ProtocolDiamond, and Diamond utility facets...`
   );

e2e/docker-compose.yml

@@ -19,7 +19,7 @@ services:
 
   hardhat-node:
     build: ../contracts
-    image: hardhat-node:a24305388c8a2b86cb59667e184677ab8862ebf2
+    image: hardhat-node:a24305388c8a2b86cb59667e184677ab8862ebf5
     ports:
       - "8545:8545"
 

e2e/tests/core-sdk.test.ts

@@ -1,11 +1,15 @@
-import { DAY_IN_MS, DAY_IN_SEC } from "./../../packages/core-sdk/tests/mocks";
+import {
+  DAY_IN_MS,
+  DAY_IN_SEC,
+  ZERO_ADDRESS
+} from "./../../packages/core-sdk/tests/mocks";
 import { CreateSellerArgs } from "./../../packages/common/src/types/accounts";
 import { CreateOfferArgs } from "./../../packages/common/src/types/offers";
 import {
   DisputeState,
   ExchangeFieldsFragment
 } from "./../../packages/core-sdk/src/subgraph";
-import { utils, constants, BigNumber, BigNumberish } from "ethers";
+import { utils, constants, BigNumber, BigNumberish, Wallet } from "ethers";
 
 import { mockCreateOfferArgs } from "../../packages/common/tests/mocks";
 import { CoreSDK } from "../../packages/core-sdk/src";
@@ -26,8 +30,13 @@ import {
   seedWallet5,
   seedWallet6,
   initCoreSDKWithWallet,
-  drWallet
+  drWallet,
+  provider,
+  ownerOfErc721Token,
+  mintErc721Token
 } from "./utils";
+import { getDefaultConfig, AuthTokenType } from "@bosonprotocol/common";
+import { EthersAdapter } from "../../packages/ethers-sdk/src";
 
 const seedWallet = seedWallet4; // be sure the seedWallet is not used by another test (to allow concurrent run)
 const sellerWallet2 = seedWallet5; // be sure the seedWallet is not used by another test (to allow concurrent run)
@@ -585,6 +594,107 @@ describe("core-sdk", () => {
       expect(seller2).toBeTruthy();
       expect(seller2.id).toEqual(sellerId);
     });
+
+    // This test requires a patch in the protocol-contracts submodule
+    //   --> MockNFTAuth721 to inherit from ERC721EnumerableUpgradeable instead of ERC721Upgradeable
+    //  (to be imported from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";)
+    // Deactivate the test until the submodule is updated
+    xtest("getSellerByAddress() retrieve the seller using the auth token", async () => {
+      const { coreSDK, fundedWallet } = await initCoreSDKWithFundedWallet(
+        seedWallet
+      );
+
+      const tokenType = AuthTokenType.LENS; // LENS
+      const defaultConfig = getDefaultConfig("local");
+      const lensContract = defaultConfig.lens?.LENS_HUB_CONTRACT as string;
+      const web3Lib = new EthersAdapter(provider, fundedWallet);
+      const originalAddress = fundedWallet.address;
+
+      // find a tokenId that is not minted yet
+      let tokenId = 123456789;
+      let ownerOf = "NOT_ZERO_ADDRESS";
+      while (ownerOf !== ZERO_ADDRESS) {
+        try {
+          ownerOf = await ownerOfErc721Token({
+            tokenId: tokenId.toString(),
+            contractAddress: lensContract,
+            web3Lib
+          });
+          tokenId++;
+        } catch {
+          ownerOf = ZERO_ADDRESS;
+        }
+      }
+
+      // Check the (future) seller doesn't own any auth token yet
+      let lensTokens = [] as string[];
+      lensTokens = await coreSDK.fetchUserAuthTokens(
+        originalAddress,
+        tokenType
+      );
+      expect(lensTokens.length).toEqual(0);
+
+      // Mint the token in the mocked LENS contract for the future seller
+      const tx = await mintErc721Token({
+        to: originalAddress,
+        tokenId: tokenId.toString(),
+        contractAddress: lensContract,
+        web3Lib
+      });
+      tx.wait();
+
+      // Check the (future) seller now owns an auth token
+      lensTokens = await coreSDK.fetchUserAuthTokens(
+        originalAddress,
+        tokenType
+      );
+      expect(lensTokens.length).toEqual(1);
+
+      // Create the seller account, using originalAddress
+      const seller = await createSeller(coreSDK, originalAddress);
+      expect(seller).toBeTruthy();
+
+      // Create a new address
+      const sellerId = seller.id;
+      const newWallet = Wallet.createRandom().connect(provider);
+      const newAddress = newWallet.address;
+
+      // Update the seller to assign the auth token and assign the new address to all accounts
+      const updateSellerTx = await coreSDK.updateSeller({
+        id: sellerId,
+        operator: newAddress,
+        admin: ZERO_ADDRESS, // need to be set to 0 when using auth token
+        clerk: newAddress,
+        treasury: newAddress,
+        authTokenId: tokenId.toString(),
+        authTokenType: tokenType
+      });
+      await updateSellerTx.wait();
+      await waitForGraphNodeIndexing();
+
+      // Check the seller is found using the auth token
+      const sellerAuthToken = await coreSDK.getSellerByAuthToken(
+        tokenId.toString(),
+        tokenType
+      );
+      expect(sellerAuthToken).toBeTruthy();
+      expect(sellerAuthToken.id).toEqual(sellerId);
+
+      // Check the seller is NOT found using the previous address
+      const operator = await coreSDK.getSellerByOperator(originalAddress);
+      expect(operator).not.toBeTruthy();
+      const admin = await coreSDK.getSellerByAdmin(originalAddress);
+      expect(admin).not.toBeTruthy();
+      const clerk = await coreSDK.getSellerByClerk(originalAddress);
+      expect(clerk).not.toBeTruthy();
+      const treasury = await coreSDK.getSellerByTreasury(originalAddress);
+      expect(treasury).not.toBeTruthy();
+
+      // Check the seller is found using the generic method
+      const seller2 = await coreSDK.getSellerByAddress(originalAddress);
+      expect(seller2).toBeTruthy();
+      expect(seller2.id).toEqual(sellerId);
+    });
   });
 });
 

e2e/tests/utils.ts

@@ -9,7 +9,8 @@ import {
 import {
   CoreSDK,
   getDefaultConfig,
-  accounts
+  accounts,
+  erc721
 } from "../../packages/core-sdk/src";
 import { IpfsMetadataStorage } from "../../packages/ipfs-storage/src";
 import { EthersAdapter } from "../../packages/ethers-sdk/src";
@@ -25,6 +26,7 @@ import {
   ACCOUNT_9,
   ACCOUNT_10
 } from "../../contracts/accounts";
+import { TransactionResponse, Web3LibAdapter } from "@bosonprotocol/common";
 
 export const MOCK_ERC20_ADDRESS =
   getDefaultConfig("local").contracts.testErc20 ||
@@ -304,3 +306,32 @@ export async function createDisputeResolver(
     protocolAdminCoreSDK: coreSDK
   };
 }
+
+export async function mintErc721Token(args: {
+  to: string;
+  tokenId: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  const erc721Iface = erc721.iface.erc721Iface;
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: erc721Iface.encodeFunctionData("mint", [args.to, args.tokenId])
+  });
+}
+
+export async function ownerOfErc721Token(args: {
+  tokenId: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const erc721Iface = erc721.iface.erc721Iface;
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: erc721Iface.encodeFunctionData("ownerOf", [args.tokenId])
+  });
+
+  const [owner] = erc721Iface.decodeFunctionResult("ownerOf", result);
+  return String(owner);
+}