thirdweb 5.44.2-nightly-7c2f616dfe6880beefa4eb48f8dcbce6bba9461a-20240808000401 → 5.45.0

package/src/extensions/marketplace/direct-listings/direct-listings.test.ts

@@ -32,133 +32,131 @@ import { isListingValid } from "./utils.js";
 import { buyFromListing } from "./write/buyFromListing.js";
 import { createListing } from "./write/createListing.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)(
-  "Marketplace: Direct Listings",
-  () => {
-    describe("ERC721", () => {
-      let nftTokenId: bigint;
-      let marketplaceContract: ThirdwebContract;
-      let erc721Contract: ThirdwebContract;
-      beforeAll(async () => {
-        marketplaceContract = getContract({
-          address: await deployMarketplaceContract({
-            account: TEST_ACCOUNT_A,
-            chain: ANVIL_CHAIN,
-            client: TEST_CLIENT,
-            params: {
-              name: "TestMarketPlace",
-            },
-          }),
-          client: TEST_CLIENT,
+describe.skip("Marketplace: Direct Listings", () => {
+  describe("ERC721", () => {
+    let nftTokenId: bigint;
+    let marketplaceContract: ThirdwebContract;
+    let erc721Contract: ThirdwebContract;
+    beforeAll(async () => {
+      marketplaceContract = getContract({
+        address: await deployMarketplaceContract({
+          account: TEST_ACCOUNT_A,
           chain: ANVIL_CHAIN,
-        });
-
-        // also deploy an ERC721 contract
-        erc721Contract = getContract({
-          address: await deployERC721Contract({
-            type: "TokenERC721",
-            account: TEST_ACCOUNT_A,
-            chain: ANVIL_CHAIN,
-            client: TEST_CLIENT,
-            params: {
-              name: "TestERC721",
-            },
-          }),
           client: TEST_CLIENT,
-          chain: ANVIL_CHAIN,
-        });
+          params: {
+            name: "TestMarketPlace",
+          },
+        }),
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+      });
 
-        const receipt = await sendAndConfirmTransaction({
-          transaction: mintToErc721({
-            contract: erc721Contract,
-            to: TEST_ACCOUNT_A.address,
-            nft: { name: "Test:ERC721:DirectListing" },
-          }),
+      // also deploy an ERC721 contract
+      erc721Contract = getContract({
+        address: await deployERC721Contract({
+          type: "TokenERC721",
           account: TEST_ACCOUNT_A,
-        });
+          chain: ANVIL_CHAIN,
+          client: TEST_CLIENT,
+          params: {
+            name: "TestERC721",
+          },
+        }),
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+      });
 
-        const mintEvents = parseEventLogs({
-          events: [tokensMintedEventErc721()],
-          logs: receipt.logs,
-        });
+      const receipt = await sendAndConfirmTransaction({
+        transaction: mintToErc721({
+          contract: erc721Contract,
+          to: TEST_ACCOUNT_A.address,
+          nft: { name: "Test:ERC721:DirectListing" },
+        }),
+        account: TEST_ACCOUNT_A,
+      });
 
-        expect(mintEvents.length).toBe(1);
-        expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
+      const mintEvents = parseEventLogs({
+        events: [tokensMintedEventErc721()],
+        logs: receipt.logs,
+      });
 
-        nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
-        // does a lot of stuff, this may take a while
-      }, 120_000);
+      expect(mintEvents.length).toBe(1);
+      expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
 
-      it("should work for basic listings (Native Currency)", async () => {
-        // listings should be 0 length to start
-        const listings = await getAllListings({
-          contract: marketplaceContract,
-        });
-        expect(listings.length).toBe(0);
-        // oh and so should totalListings
-        expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
+      nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
+      // does a lot of stuff, this may take a while
+    }, 120_000);
 
-        // approve first
-        const approveTx = approveErc721({
-          contract: erc721Contract,
-          to: marketplaceContract.address,
-          tokenId: nftTokenId,
-        });
+    it("should work for basic listings (Native Currency)", async () => {
+      // listings should be 0 length to start
+      const listings = await getAllListings({
+        contract: marketplaceContract,
+      });
+      expect(listings.length).toBe(0);
+      // oh and so should totalListings
+      expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
+
+      // approve first
+      const approveTx = approveErc721({
+        contract: erc721Contract,
+        to: marketplaceContract.address,
+        tokenId: nftTokenId,
+      });
 
-        await sendAndConfirmTransaction({
-          transaction: approveTx,
-          account: TEST_ACCOUNT_A,
-        });
+      await sendAndConfirmTransaction({
+        transaction: approveTx,
+        account: TEST_ACCOUNT_A,
+      });
 
-        const transaction = createListing({
-          contract: marketplaceContract,
-          assetContractAddress: erc721Contract.address,
-          tokenId: nftTokenId,
-          pricePerToken: "1",
-        });
-        const receipt = await sendAndConfirmTransaction({
-          transaction,
-          account: TEST_ACCOUNT_A,
-        });
+      const transaction = createListing({
+        contract: marketplaceContract,
+        assetContractAddress: erc721Contract.address,
+        tokenId: nftTokenId,
+        pricePerToken: "1",
+      });
+      const receipt = await sendAndConfirmTransaction({
+        transaction,
+        account: TEST_ACCOUNT_A,
+      });
 
-        const listingEvents = parseEventLogs({
-          events: [newListingEvent()],
-          logs: receipt.logs,
-        });
+      const listingEvents = parseEventLogs({
+        events: [newListingEvent()],
+        logs: receipt.logs,
+      });
 
-        expect(listingEvents.length).toBe(1);
+      expect(listingEvents.length).toBe(1);
 
-        // biome-ignore lint/style/noNonNullAssertion: OK in tests
-        const listingEvent = listingEvents[0]!;
+      // biome-ignore lint/style/noNonNullAssertion: OK in tests
+      const listingEvent = listingEvents[0]!;
 
-        expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
-        expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
+      expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
+      expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
 
-        // at this point listings should be 1
-        const listingsAfter = await getAllListings({
-          contract: marketplaceContract,
-        });
-        expect(listingsAfter.length).toBe(1);
-        // valid listings should also be 1!
-        const validListings = await getAllValidListings({
-          contract: marketplaceContract,
-        });
-        expect(validListings.length).toBe(1);
-        // and totalListings should be 1
-        expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
+      // at this point listings should be 1
+      const listingsAfter = await getAllListings({
+        contract: marketplaceContract,
+      });
+      expect(listingsAfter.length).toBe(1);
+      // valid listings should also be 1!
+      const validListings = await getAllValidListings({
+        contract: marketplaceContract,
+      });
+      expect(validListings.length).toBe(1);
+      // and totalListings should be 1
+      expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
+
+      // explicitly retrieve the listing!
+      const listing = await getListing({
+        contract: marketplaceContract,
+        listingId: listingEvent.args.listingId,
+      });
 
-        // explicitly retrieve the listing!
-        const listing = await getListing({
-          contract: marketplaceContract,
-          listingId: listingEvent.args.listingId,
-        });
-
-        expect(listing).toBeDefined();
-        expect(listing.status).toBe("ACTIVE");
-        expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
-        expect(listing.assetContractAddress).toBe(erc721Contract.address);
-        expect(listing.tokenId).toBe(nftTokenId);
-        expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
+      expect(listing).toBeDefined();
+      expect(listing.status).toBe("ACTIVE");
+      expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
+      expect(listing.assetContractAddress).toBe(erc721Contract.address);
+      expect(listing.tokenId).toBe(nftTokenId);
+      expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
       {
         "decimals": 18,
         "displayValue": "1",
@@ -167,7 +165,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         "value": 1000000000000000000n,
       }
     `);
-        expect(listing.asset).toMatchInlineSnapshot(`
+      expect(listing.asset).toMatchInlineSnapshot(`
       {
         "id": 0n,
         "metadata": {
@@ -179,218 +177,218 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       }
     `);
 
-        // check the listing is valid
-        const listingValidity = await isListingValid({
-          listing,
-          contract: marketplaceContract,
-          quantity: 1n,
-        });
+      // check the listing is valid
+      const listingValidity = await isListingValid({
+        listing,
+        contract: marketplaceContract,
+        quantity: 1n,
+      });
 
-        expect(listingValidity).toMatchInlineSnapshot(`
+      expect(listingValidity).toMatchInlineSnapshot(`
       {
         "valid": true,
       }
     `);
 
-        // expect the buyer to have an initial balance of 0
-        await expect(
-          balanceOfErc721({
-            contract: erc721Contract,
-            owner: TEST_ACCOUNT_B.address,
-          }),
-        ).resolves.toBe(0n);
+      // expect the buyer to have an initial balance of 0
+      await expect(
+        balanceOfErc721({
+          contract: erc721Contract,
+          owner: TEST_ACCOUNT_B.address,
+        }),
+      ).resolves.toBe(0n);
+
+      const buyTx = buyFromListing({
+        contract: marketplaceContract,
+        listingId: listingEvent.args.listingId,
+        recipient: TEST_ACCOUNT_B.address,
+        quantity: 1n,
+      });
 
-        const buyTx = buyFromListing({
-          contract: marketplaceContract,
-          listingId: listingEvent.args.listingId,
-          recipient: TEST_ACCOUNT_B.address,
-          quantity: 1n,
-        });
-
-        await sendAndConfirmTransaction({
-          transaction: buyTx,
-          account: TEST_ACCOUNT_B,
-        });
-
-        // expect the buyer to have a new balance of 1
-        await expect(
-          balanceOfErc721({
-            contract: erc721Contract,
-            owner: TEST_ACCOUNT_B.address,
-          }),
-        ).resolves.toBe(1n);
-        // expect the seller to no longer have the token
-        await expect(
-          balanceOfErc721({
-            contract: erc721Contract,
-            owner: TEST_ACCOUNT_A.address,
-          }),
-        ).resolves.toBe(0n);
+      await sendAndConfirmTransaction({
+        transaction: buyTx,
+        account: TEST_ACCOUNT_B,
       });
-    });
 
-    describe("ERC1155 Drop", () => {
-      let nftTokenId: bigint;
-      let marketplaceContract: ThirdwebContract;
-      let erc1155Contract: ThirdwebContract;
-      beforeAll(async () => {
-        marketplaceContract = getContract({
-          address: await deployMarketplaceContract({
-            account: TEST_ACCOUNT_A,
-            chain: ANVIL_CHAIN,
-            client: TEST_CLIENT,
-            params: {
-              name: "TestMarketPlace",
-            },
-          }),
-          client: TEST_CLIENT,
+      // expect the buyer to have a new balance of 1
+      await expect(
+        balanceOfErc721({
+          contract: erc721Contract,
+          owner: TEST_ACCOUNT_B.address,
+        }),
+      ).resolves.toBe(1n);
+      // expect the seller to no longer have the token
+      await expect(
+        balanceOfErc721({
+          contract: erc721Contract,
+          owner: TEST_ACCOUNT_A.address,
+        }),
+      ).resolves.toBe(0n);
+    });
+  });
+
+  describe("ERC1155 Drop", () => {
+    let nftTokenId: bigint;
+    let marketplaceContract: ThirdwebContract;
+    let erc1155Contract: ThirdwebContract;
+    beforeAll(async () => {
+      marketplaceContract = getContract({
+        address: await deployMarketplaceContract({
+          account: TEST_ACCOUNT_A,
           chain: ANVIL_CHAIN,
-        });
-
-        // also deploy an ERC721 contract
-        erc1155Contract = getContract({
-          address: await deployERC1155Contract({
-            type: "DropERC1155",
-            account: TEST_ACCOUNT_A,
-            chain: ANVIL_CHAIN,
-            client: TEST_CLIENT,
-            params: {
-              name: "TestERC1155",
-            },
-          }),
           client: TEST_CLIENT,
-          chain: ANVIL_CHAIN,
-        });
-
-        // lazy mint 10 tokens
-        await expect(
-          sendAndConfirmTransaction({
-            transaction: lazyMint({
-              contract: erc1155Contract,
-              nfts: [{ name: "Test:ERC1155:DirectListing" }],
-            }),
-            account: TEST_ACCOUNT_A,
-          }),
-        ).resolves.toBeDefined();
-
-        // set claim condition (just public is fine)
-        await expect(
-          sendAndConfirmTransaction({
-            transaction: setClaimConditions({
-              contract: erc1155Contract,
-              tokenId: 0n,
-              phases: [{}],
-            }),
-            account: TEST_ACCOUNT_A,
-          }),
-        ).resolves.toBeDefined();
-
-        // claim 10 tokens
-        await expect(
-          sendAndConfirmTransaction({
-            transaction: claimTo({
-              contract: erc1155Contract,
-              tokenId: 0n,
-              to: TEST_ACCOUNT_A.address,
-              quantity: 10n,
-            }),
-            account: TEST_ACCOUNT_A,
-          }),
-        ).resolves.toBeDefined();
-
-        nftTokenId = 0n;
-        // does a lot of stuff, this may take a while
-      }, 120_000);
+          params: {
+            name: "TestMarketPlace",
+          },
+        }),
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+      });
 
-      it("should work for basic listings (Native Currency)", async () => {
-        // listings should be 0 length to start
-        const listings = await getAllListings({
-          contract: marketplaceContract,
-        });
-        expect(listings.length).toBe(0);
-        // oh and so should totalListings
-        expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
+      // also deploy an ERC721 contract
+      erc1155Contract = getContract({
+        address: await deployERC1155Contract({
+          type: "DropERC1155",
+          account: TEST_ACCOUNT_A,
+          chain: ANVIL_CHAIN,
+          client: TEST_CLIENT,
+          params: {
+            name: "TestERC1155",
+          },
+        }),
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+      });
 
-        // approve first
+      // lazy mint 10 tokens
+      await expect(
+        sendAndConfirmTransaction({
+          transaction: lazyMint({
+            contract: erc1155Contract,
+            nfts: [{ name: "Test:ERC1155:DirectListing" }],
+          }),
+          account: TEST_ACCOUNT_A,
+        }),
+      ).resolves.toBeDefined();
 
-        await sendAndConfirmTransaction({
-          transaction: setApprovalForAll({
+      // set claim condition (just public is fine)
+      await expect(
+        sendAndConfirmTransaction({
+          transaction: setClaimConditions({
             contract: erc1155Contract,
-            operator: marketplaceContract.address,
-            approved: true,
+            tokenId: 0n,
+            phases: [{}],
           }),
           account: TEST_ACCOUNT_A,
-        });
-
-        // this should fail because we're listing more than we have
-        await expect(
-          sendAndConfirmTransaction({
-            transaction: createListing({
-              contract: marketplaceContract,
-              assetContractAddress: erc1155Contract.address,
-              tokenId: nftTokenId,
-              pricePerToken: "1",
-              quantity: 20n,
-            }),
-            account: TEST_ACCOUNT_A,
+        }),
+      ).resolves.toBeDefined();
+
+      // claim 10 tokens
+      await expect(
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract: erc1155Contract,
+            tokenId: 0n,
+            to: TEST_ACCOUNT_A.address,
+            quantity: 10n,
           }),
-        ).rejects.toThrowErrorMatchingInlineSnapshot(`
-        [TransactionError: Error - Marketplace: not owner or approved tokens.
+          account: TEST_ACCOUNT_A,
+        }),
+      ).resolves.toBeDefined();
 
-        contract: ${marketplaceContract.address}
-        chainId: 31337]
-      `);
+      nftTokenId = 0n;
+      // does a lot of stuff, this may take a while
+    }, 120_000);
+
+    it("should work for basic listings (Native Currency)", async () => {
+      // listings should be 0 length to start
+      const listings = await getAllListings({
+        contract: marketplaceContract,
+      });
+      expect(listings.length).toBe(0);
+      // oh and so should totalListings
+      expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
+
+      // approve first
+
+      await sendAndConfirmTransaction({
+        transaction: setApprovalForAll({
+          contract: erc1155Contract,
+          operator: marketplaceContract.address,
+          approved: true,
+        }),
+        account: TEST_ACCOUNT_A,
+      });
 
-        // this should work because we're listing the correct amount
-        const receipt = await sendAndConfirmTransaction({
+      // this should fail because we're listing more than we have
+      await expect(
+        sendAndConfirmTransaction({
           transaction: createListing({
             contract: marketplaceContract,
             assetContractAddress: erc1155Contract.address,
             tokenId: nftTokenId,
-            pricePerToken: "0.01",
-            quantity: 1n,
+            pricePerToken: "1",
+            quantity: 20n,
           }),
           account: TEST_ACCOUNT_A,
-        });
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        [TransactionError: Error - Marketplace: not owner or approved tokens.
 
-        const listingEvents = parseEventLogs({
-          events: [newListingEvent()],
-          logs: receipt.logs,
-        });
+        contract: ${marketplaceContract.address}
+        chainId: 31337]
+      `);
 
-        expect(listingEvents.length).toBe(1);
+      // this should work because we're listing the correct amount
+      const receipt = await sendAndConfirmTransaction({
+        transaction: createListing({
+          contract: marketplaceContract,
+          assetContractAddress: erc1155Contract.address,
+          tokenId: nftTokenId,
+          pricePerToken: "0.01",
+          quantity: 1n,
+        }),
+        account: TEST_ACCOUNT_A,
+      });
 
-        // biome-ignore lint/style/noNonNullAssertion: OK in tests
-        const listingEvent = listingEvents[0]!;
+      const listingEvents = parseEventLogs({
+        events: [newListingEvent()],
+        logs: receipt.logs,
+      });
 
-        expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
-        expect(listingEvent.args.assetContract).toBe(erc1155Contract.address);
+      expect(listingEvents.length).toBe(1);
 
-        // at this point listings should be 1
-        const listingsAfter = await getAllListings({
-          contract: marketplaceContract,
-        });
-        expect(listingsAfter.length).toBe(1);
-        // valid listings should also be 1!
-        const validListings = await getAllValidListings({
-          contract: marketplaceContract,
-        });
-        expect(validListings.length).toBe(1);
-        // and totalListings should be 1
-        expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
+      // biome-ignore lint/style/noNonNullAssertion: OK in tests
+      const listingEvent = listingEvents[0]!;
 
-        // explicitly retrieve the listing!
-        const listing = await getListing({
-          contract: marketplaceContract,
-          listingId: listingEvent.args.listingId,
-        });
-
-        expect(listing).toBeDefined();
-        expect(listing.status).toBe("ACTIVE");
-        expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
-        expect(listing.assetContractAddress).toBe(erc1155Contract.address);
-        expect(listing.tokenId).toBe(nftTokenId);
-        expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
+      expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
+      expect(listingEvent.args.assetContract).toBe(erc1155Contract.address);
+
+      // at this point listings should be 1
+      const listingsAfter = await getAllListings({
+        contract: marketplaceContract,
+      });
+      expect(listingsAfter.length).toBe(1);
+      // valid listings should also be 1!
+      const validListings = await getAllValidListings({
+        contract: marketplaceContract,
+      });
+      expect(validListings.length).toBe(1);
+      // and totalListings should be 1
+      expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
+
+      // explicitly retrieve the listing!
+      const listing = await getListing({
+        contract: marketplaceContract,
+        listingId: listingEvent.args.listingId,
+      });
+
+      expect(listing).toBeDefined();
+      expect(listing.status).toBe("ACTIVE");
+      expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
+      expect(listing.assetContractAddress).toBe(erc1155Contract.address);
+      expect(listing.tokenId).toBe(nftTokenId);
+      expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
         {
           "decimals": 18,
           "displayValue": "0.01",
@@ -399,7 +397,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           "value": 10000000000000000n,
         }
       `);
-        expect(listing.asset).toMatchInlineSnapshot(`
+      expect(listing.asset).toMatchInlineSnapshot(`
         {
           "id": 0n,
           "metadata": {
@@ -412,57 +410,56 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         }
       `);
 
-        // check the listing is valid
-        const listingValidity = await isListingValid({
-          listing,
-          contract: marketplaceContract,
-          quantity: 1n,
-        });
+      // check the listing is valid
+      const listingValidity = await isListingValid({
+        listing,
+        contract: marketplaceContract,
+        quantity: 1n,
+      });
 
-        expect(listingValidity).toMatchInlineSnapshot(`
+      expect(listingValidity).toMatchInlineSnapshot(`
         {
           "valid": true,
         }
       `);
 
-        // expect the buyer to have an initial balance of 0
-        await expect(
-          balanceOfErc1155({
-            contract: erc1155Contract,
-            owner: TEST_ACCOUNT_B.address,
-            tokenId: nftTokenId,
-          }),
-        ).resolves.toBe(0n);
-
-        const buyTx = buyFromListing({
-          contract: marketplaceContract,
-          listingId: listingEvent.args.listingId,
-          recipient: TEST_ACCOUNT_B.address,
-          quantity: 1n,
-        });
-
-        await sendAndConfirmTransaction({
-          transaction: buyTx,
-          account: TEST_ACCOUNT_B,
-        });
+      // expect the buyer to have an initial balance of 0
+      await expect(
+        balanceOfErc1155({
+          contract: erc1155Contract,
+          owner: TEST_ACCOUNT_B.address,
+          tokenId: nftTokenId,
+        }),
+      ).resolves.toBe(0n);
+
+      const buyTx = buyFromListing({
+        contract: marketplaceContract,
+        listingId: listingEvent.args.listingId,
+        recipient: TEST_ACCOUNT_B.address,
+        quantity: 1n,
+      });
 
-        // expect the buyer to have a new balance of 1
-        await expect(
-          balanceOfErc1155({
-            contract: erc1155Contract,
-            owner: TEST_ACCOUNT_B.address,
-            tokenId: nftTokenId,
-          }),
-        ).resolves.toBe(1n);
-        // expect the seller to only have 9 of the tokens
-        await expect(
-          balanceOfErc1155({
-            contract: erc1155Contract,
-            owner: TEST_ACCOUNT_A.address,
-            tokenId: nftTokenId,
-          }),
-        ).resolves.toBe(9n);
+      await sendAndConfirmTransaction({
+        transaction: buyTx,
+        account: TEST_ACCOUNT_B,
       });
+
+      // expect the buyer to have a new balance of 1
+      await expect(
+        balanceOfErc1155({
+          contract: erc1155Contract,
+          owner: TEST_ACCOUNT_B.address,
+          tokenId: nftTokenId,
+        }),
+      ).resolves.toBe(1n);
+      // expect the seller to only have 9 of the tokens
+      await expect(
+        balanceOfErc1155({
+          contract: erc1155Contract,
+          owner: TEST_ACCOUNT_A.address,
+          tokenId: nftTokenId,
+        }),
+      ).resolves.toBe(9n);
     });
-  },
-);
+  });
+});