thirdweb 5.57.0 → 5.57.1

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

@@ -1,25 +1,21 @@
-import { beforeAll, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
 import { ANVIL_CHAIN } from "../../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
 import {
   TEST_ACCOUNT_A,
   TEST_ACCOUNT_B,
+  TEST_ACCOUNT_C,
 } from "../../../../test/src/test-wallets.js";
-import {
-  type ThirdwebContract,
-  getContract,
-} from "../../../contract/contract.js";
+import { getContract } from "../../../contract/contract.js";
 import { parseEventLogs } from "../../../event/actions/parse-logs.js";
+import { setApprovalForAll as setApprovalForAll721 } from "../../../extensions/erc721/__generated__/IERC721A/write/setApprovalForAll.js";
+import { mintTo as mintToErc1155 } from "../../../extensions/erc1155/write/mintTo.js";
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
 import { balanceOf as balanceOfErc721 } from "../../erc721/__generated__/IERC721A/read/balanceOf.js";
-import { approve as approveErc721 } from "../../erc721/__generated__/IERC721A/write/approve.js";
-import { tokensMintedEvent as tokensMintedEventErc721 } from "../../erc721/__generated__/IMintableERC721/events/TokensMinted.js";
 import { mintTo as mintToErc721 } from "../../erc721/write/mintTo.js";
 import { balanceOf as balanceOfErc1155 } from "../../erc1155/__generated__/IERC1155/read/balanceOf.js";
-import { setApprovalForAll } from "../../erc1155/__generated__/IERC1155/write/setApprovalForAll.js";
-import { claimTo } from "../../erc1155/drops/write/claimTo.js";
-import { setClaimConditions } from "../../erc1155/drops/write/setClaimConditions.js";
-import { lazyMint } from "../../erc1155/write/lazyMint.js";
+import { setApprovalForAll as setApprovalForAll1155 } from "../../erc1155/__generated__/IERC1155/write/setApprovalForAll.js";
 import { deployERC721Contract } from "../../prebuilts/deploy-erc721.js";
 import { deployERC1155Contract } from "../../prebuilts/deploy-erc1155.js";
 import { deployMarketplaceContract } from "../../prebuilts/deploy-marketplace.js";
@@ -32,434 +28,361 @@ import { isListingValid } from "./utils.js";
 import { buyFromListing } from "./write/buyFromListing.js";
 import { createListing } from "./write/createListing.js";
 
-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,
-          client: TEST_CLIENT,
-          params: {
-            name: "TestMarketPlace",
-          },
-        }),
-        client: TEST_CLIENT,
-        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,
-      });
+const chain = ANVIL_CHAIN;
+const client = TEST_CLIENT;
+
+describe.runIf(process.env.TW_SECRET_KEY)("Marketplace Direct Listings", () => {
+  it("should work with ERC721 and ERC1155", async () => {
+    const marketplaceAddress = await deployMarketplaceContract({
+      account: TEST_ACCOUNT_A,
+      chain,
+      client,
+      params: {
+        name: "TestMarketPlace",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const erc721Address = await deployERC721Contract({
+      type: "TokenERC721",
+      account: TEST_ACCOUNT_B,
+      chain,
+      client,
+      params: {
+        name: "TestERC721",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const erc1155Address = await deployERC1155Contract({
+      type: "TokenERC1155",
+      account: TEST_ACCOUNT_C,
+      chain,
+      client,
+      params: {
+        name: "TestERC1155",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+
+    const marketplaceContract = getContract({
+      address: marketplaceAddress,
+      chain,
+      client,
+    });
+    const erc721Contract = getContract({
+      address: erc721Address,
+      chain,
+      client,
+    });
+    const erc1155Contract = getContract({
+      address: erc1155Address,
+      chain,
+      client,
+    });
 
-      const receipt = await sendAndConfirmTransaction({
+    // Mint some NFTs in parallel
+    await Promise.all([
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
         transaction: mintToErc721({
           contract: erc721Contract,
-          to: TEST_ACCOUNT_A.address,
-          nft: { name: "Test:ERC721:DirectListing" },
+          nft: { name: "erc721 #0" },
+          to: TEST_ACCOUNT_B.address,
         }),
-        account: TEST_ACCOUNT_A,
-      });
-
-      const mintEvents = parseEventLogs({
-        events: [tokensMintedEventErc721()],
-        logs: receipt.logs,
-      });
+      }),
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_C,
+        transaction: mintToErc1155({
+          contract: erc1155Contract,
+          nft: { name: "erc1155 #0" },
+          to: TEST_ACCOUNT_C.address,
+          supply: 100n,
+        }),
+      }),
+    ]);
 
-      expect(mintEvents.length).toBe(1);
-      expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
+    // Set NFT approvals
+    await Promise.all([
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: setApprovalForAll721({
+          contract: erc721Contract,
+          approved: true,
+          operator: marketplaceAddress,
+        }),
+      }),
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_C,
+        transaction: setApprovalForAll1155({
+          contract: erc1155Contract,
+          approved: true,
+          operator: marketplaceAddress,
+        }),
+      }),
+    ]);
 
-      nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
-      // does a lot of stuff, this may take a while
-    }, 120_000);
+    // ---- set up completed ---- //
 
-    it("should work for basic listings (Native Currency)", async () => {
-      // listings should be 0 length to start
-      const listings = await getAllListings({
+    // listings should be 0 length to start
+    const [allListings, totalListingCount] = await Promise.all([
+      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,
-      });
-
-      const transaction = createListing({
+      }),
+      totalListings({ contract: marketplaceContract }),
+    ]);
+    expect(allListings.length).toBe(0);
+    // oh and so should totalListings
+    expect(totalListingCount).toBe(0n);
+
+    const receipt = await sendAndConfirmTransaction({
+      transaction: createListing({
         contract: marketplaceContract,
         assetContractAddress: erc721Contract.address,
-        tokenId: nftTokenId,
+        tokenId: 0n,
         pricePerToken: "1",
-      });
-      const receipt = await sendAndConfirmTransaction({
-        transaction,
-        account: TEST_ACCOUNT_A,
-      });
+      }),
+      account: TEST_ACCOUNT_B,
+    });
 
-      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_B.address);
+    expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
 
-      // at this point listings should be 1
-      const listingsAfter = await getAllListings({
+    const [
+      listingsAfter,
+      validListings,
+      totalListingCount2,
+      firstListing,
+      nftBalanceOfAccountABeforePurchase,
+    ] = await Promise.all([
+      getAllListings({
         contract: marketplaceContract,
-      });
-      expect(listingsAfter.length).toBe(1);
-      // valid listings should also be 1!
-      const validListings = await getAllValidListings({
+      }),
+      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({
+      }),
+      totalListings({ contract: marketplaceContract }),
+      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(`
-      {
-        "decimals": 18,
-        "displayValue": "1",
-        "name": "Anvil Ether",
-        "symbol": "ETH",
-        "value": 1000000000000000000n,
-      }
-    `);
-      expect(listing.asset).toMatchInlineSnapshot(`
-      {
-        "id": 0n,
-        "metadata": {
-          "name": "Test:ERC721:DirectListing",
-        },
-        "owner": null,
-        "tokenURI": "ipfs://QmewoGwuooC1Vno1ZTnmKmEUaimDygraR1fEEHdTeraF34/0",
-        "type": "ERC721",
-      }
-    `);
-
-      // check the listing is valid
-      const listingValidity = await isListingValid({
-        listing,
-        contract: marketplaceContract,
-        quantity: 1n,
-      });
+      }),
+      balanceOfErc721({
+        contract: erc721Contract,
+        owner: TEST_ACCOUNT_A.address,
+      }),
+    ]);
+
+    // at this point listings should be 1
+    expect(listingsAfter.length).toBe(1);
+    // valid listings should also be 1!
+    expect(validListings.length).toBe(1);
+    // and totalListings should be 1
+    expect(totalListingCount2).toBe(1n);
+    expect(firstListing).toBeDefined();
+    expect(firstListing.status).toBe("ACTIVE");
+    expect(firstListing.creatorAddress).toBe(TEST_ACCOUNT_B.address);
+    expect(firstListing.assetContractAddress).toBe(erc721Contract.address);
+    expect(firstListing.tokenId).toBe(0n);
+    expect(firstListing.currencyValuePerToken).toMatchInlineSnapshot(`
+    {
+      "decimals": 18,
+      "displayValue": "1",
+      "name": "Anvil Ether",
+      "symbol": "ETH",
+      "value": 1000000000000000000n,
+    }
+  `);
+    expect(firstListing.asset.metadata.name).toBe("erc721 #0");
+    expect(firstListing.asset.id).toBe(0n);
+    expect(firstListing.asset.owner).toBe(null);
+    // check the listing is valid
+    const firstListingValidity = await isListingValid({
+      listing: firstListing,
+      contract: marketplaceContract,
+      quantity: 1n,
+    });
 
-      expect(listingValidity).toMatchInlineSnapshot(`
-      {
-        "valid": true,
-      }
+    expect(firstListingValidity).toMatchInlineSnapshot(`
+    {
+      "valid": true,
+    }
     `);
+    expect(nftBalanceOfAccountABeforePurchase).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({
+    await sendAndConfirmTransaction({
+      transaction: buyFromListing({
         contract: marketplaceContract,
         listingId: listingEvent.args.listingId,
-        recipient: TEST_ACCOUNT_B.address,
+        recipient: TEST_ACCOUNT_A.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);
+      }),
+      account: TEST_ACCOUNT_A,
     });
-  });
-
-  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,
-        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);
-
-    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 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,
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(`
-        [TransactionError: Error - Marketplace: not owner or approved tokens.
-
-        contract: ${marketplaceContract.address}
-        chainId: 31337]
-      `);
-
-      // this should work because we're listing the correct amount
-      const receipt = await sendAndConfirmTransaction({
+    const [
+      nftBalanceOfAccountAAfterPurchase,
+      nftBalanceOfAccountBAfterPurchase,
+    ] = await Promise.all([
+      balanceOfErc721({
+        contract: erc721Contract,
+        owner: TEST_ACCOUNT_A.address,
+      }),
+      balanceOfErc721({
+        contract: erc721Contract,
+        owner: TEST_ACCOUNT_B.address,
+      }),
+    ]);
+    // expect the buyer to have a new balance of 1
+    expect(nftBalanceOfAccountAAfterPurchase).toBe(1n);
+    // expect the seller to no longer have the nft
+    expect(nftBalanceOfAccountBAfterPurchase).toBe(0n);
+
+    /**
+     * ============ now do the same tests but for ERC1155 =============
+     */
+
+    // 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,
+          tokenId: 0n,
+          pricePerToken: "1",
+          quantity: 101n,
         }),
-        account: TEST_ACCOUNT_A,
-      });
+        account: TEST_ACCOUNT_C,
+      }),
+    ).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);
+    const receipt1155 = await sendAndConfirmTransaction({
+      transaction: createListing({
+        contract: marketplaceContract,
+        assetContractAddress: erc1155Contract.address,
+        tokenId: 0n,
+        pricePerToken: "0.01",
+        quantity: 1n,
+      }),
+      account: TEST_ACCOUNT_C,
+    });
 
-      // biome-ignore lint/style/noNonNullAssertion: OK in tests
-      const listingEvent = listingEvents[0]!;
+    const listingEvents1155 = parseEventLogs({
+      events: [newListingEvent()],
+      logs: receipt1155.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 listingEvent1155 = listingEvents1155[0]!;
 
-      // explicitly retrieve the listing!
-      const listing = await getListing({
+    expect(listingEvent1155.args.listingCreator).toBe(TEST_ACCOUNT_C.address);
+    expect(listingEvent1155.args.assetContract).toBe(erc1155Contract.address);
+
+    const [
+      listings1155After,
+      validListings1155,
+      totalListingCountAfter1155,
+      secondListing,
+      nft1155BalanceOfAccountABeforePurchase,
+    ] = await Promise.all([
+      getAllListings({
         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",
-          "name": "Anvil Ether",
-          "symbol": "ETH",
-          "value": 10000000000000000n,
-        }
-      `);
-      expect(listing.asset).toMatchInlineSnapshot(`
-        {
-          "id": 0n,
-          "metadata": {
-            "name": "Test:ERC1155:DirectListing",
-          },
-          "owner": null,
-          "supply": 10n,
-          "tokenURI": "ipfs://QmdwzcoSGSzoRSMBk2efkHjGVRsyUaR2Lm79YTuL324NtM/0",
-          "type": "ERC1155",
-        }
-      `);
-
-      // check the listing is valid
-      const listingValidity = await isListingValid({
-        listing,
+      }),
+      getAllValidListings({
         contract: marketplaceContract,
-        quantity: 1n,
-      });
+      }),
+      totalListings({ contract: marketplaceContract }),
+      getListing({
+        contract: marketplaceContract,
+        listingId: listingEvent1155.args.listingId,
+      }),
+      balanceOfErc1155({
+        contract: erc1155Contract,
+        owner: TEST_ACCOUNT_A.address,
+        tokenId: 0n,
+      }),
+    ]);
+
+    // at this point listings should be 2
+    expect(listings1155After.length).toBe(2);
+    // valid listings should be 1 still because the first listing has been bought
+    expect(validListings1155.length).toBe(1);
+    // and totalListings should be 2
+    expect(totalListingCountAfter1155).toBe(2n);
+    expect(secondListing).toBeDefined();
+    expect(secondListing.status).toBe("ACTIVE");
+    expect(secondListing.creatorAddress).toBe(TEST_ACCOUNT_C.address);
+    expect(secondListing.assetContractAddress).toBe(erc1155Contract.address);
+    expect(secondListing.tokenId).toBe(0n);
+    expect(secondListing.currencyValuePerToken).toMatchInlineSnapshot(`
+      {
+        "decimals": 18,
+        "displayValue": "0.01",
+        "name": "Anvil Ether",
+        "symbol": "ETH",
+        "value": 10000000000000000n,
+      }
+    `);
+    expect(secondListing.asset.metadata.name).toBe("erc1155 #0");
+    expect(secondListing.asset.id).toBe(0n);
+
+    // check the listing is valid
+    const listingValidity = await isListingValid({
+      listing: secondListing,
+      contract: marketplaceContract,
+      quantity: 1n,
+    });
 
-      expect(listingValidity).toMatchInlineSnapshot(`
-        {
-          "valid": true,
-        }
-      `);
+    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);
+    expect(nft1155BalanceOfAccountABeforePurchase).toBe(0n);
 
-      const buyTx = buyFromListing({
+    await sendAndConfirmTransaction({
+      transaction: buyFromListing({
         contract: marketplaceContract,
-        listingId: listingEvent.args.listingId,
-        recipient: TEST_ACCOUNT_B.address,
+        listingId: listingEvent1155.args.listingId,
+        recipient: TEST_ACCOUNT_A.address,
         quantity: 1n,
-      });
-
-      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);
+      }),
+      account: TEST_ACCOUNT_A,
     });
+
+    const [
+      nft1155BalanceOfAccountAAfterPurchase,
+      nft1155BalanceOfAccountCAfterPurchase,
+    ] = await Promise.all([
+      balanceOfErc1155({
+        contract: erc1155Contract,
+        owner: TEST_ACCOUNT_A.address,
+        tokenId: 0n,
+      }),
+      balanceOfErc1155({
+        contract: erc1155Contract,
+        owner: TEST_ACCOUNT_C.address,
+        tokenId: 0n,
+      }),
+    ]);
+    // expect the buyer to have a new balance of 1
+    expect(nft1155BalanceOfAccountAAfterPurchase).toBe(1n);
+    // expect the seller to have one less 1155 token
+    expect(nft1155BalanceOfAccountCAfterPurchase).toBe(99n);
   });
 });