thirdweb 5.44.2-nightly-7c2f616dfe6880beefa4eb48f8dcbce6bba9461a-20240808000401 → 5.45.0

package/src/extensions/marketplace/english-auctions/english-auctions.test.ts

@@ -26,137 +26,135 @@ import { bidInAuction } from "./write/bidInAuction.js";
 import { buyoutAuction } from "./write/buyoutAuction.js";
 import { createAuction } from "./write/createAuction.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)(
-  "Marketplace: English Auctions",
-  () => {
-    let nftTokenId: bigint;
-    let marketplaceContract: ThirdwebContract;
-    let erc721Contract: ThirdwebContract;
-    beforeAll(async () => {
-      const marketplaceAddress = await deployMarketplaceContract({
-        account: TEST_ACCOUNT_A,
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "TestMarketPlace",
-        },
-      });
-      marketplaceContract = getContract({
-        address: marketplaceAddress,
-        client: TEST_CLIENT,
-        chain: ANVIL_CHAIN,
-      });
+describe.skip("Marketplace: English Auctions", () => {
+  let nftTokenId: bigint;
+  let marketplaceContract: ThirdwebContract;
+  let erc721Contract: ThirdwebContract;
+  beforeAll(async () => {
+    const marketplaceAddress = await deployMarketplaceContract({
+      account: TEST_ACCOUNT_A,
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      params: {
+        name: "TestMarketPlace",
+      },
+    });
+    marketplaceContract = getContract({
+      address: marketplaceAddress,
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
 
-      // also deploy an ERC721 contract
-      const erc721Address = await deployERC721Contract({
-        type: "TokenERC721",
-        account: TEST_ACCOUNT_A,
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "TestERC721",
-        },
-      });
+    // also deploy an ERC721 contract
+    const erc721Address = await deployERC721Contract({
+      type: "TokenERC721",
+      account: TEST_ACCOUNT_A,
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      params: {
+        name: "TestERC721",
+      },
+    });
 
-      erc721Contract = getContract({
-        address: erc721Address,
-        client: TEST_CLIENT,
-        chain: ANVIL_CHAIN,
-      });
+    erc721Contract = getContract({
+      address: erc721Address,
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
 
-      const mintTransaction = mintTo({
-        contract: erc721Contract,
-        to: TEST_ACCOUNT_A.address,
-        nft: { name: "Test:ERC721:EnglishAuction" },
-      });
-      const receipt = await sendAndConfirmTransaction({
-        transaction: mintTransaction,
-        account: TEST_ACCOUNT_A,
-      });
+    const mintTransaction = mintTo({
+      contract: erc721Contract,
+      to: TEST_ACCOUNT_A.address,
+      nft: { name: "Test:ERC721:EnglishAuction" },
+    });
+    const receipt = await sendAndConfirmTransaction({
+      transaction: mintTransaction,
+      account: TEST_ACCOUNT_A,
+    });
 
-      const mintEvents = parseEventLogs({
-        events: [tokensMintedEvent()],
-        logs: receipt.logs,
-      });
+    const mintEvents = parseEventLogs({
+      events: [tokensMintedEvent()],
+      logs: receipt.logs,
+    });
 
-      expect(mintEvents.length).toBe(1);
-      expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
+    expect(mintEvents.length).toBe(1);
+    expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
 
-      nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
-      // does a lot of stuff, this may take a while
-    }, 120_000);
+    nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
+    // does a lot of stuff, this may take a while
+  }, 120_000);
 
-    it("should work for basic auctions (Native Currency)", async () => {
-      // auctions should be 0 length to start
-      const auctions = await getAllAuctions({
-        contract: marketplaceContract,
-      });
-      expect(auctions.length).toBe(0);
-      // oh and so should totalAuctions
-      expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
+  it("should work for basic auctions (Native Currency)", async () => {
+    // auctions should be 0 length to start
+    const auctions = await getAllAuctions({
+      contract: marketplaceContract,
+    });
+    expect(auctions.length).toBe(0);
+    // oh and so should totalAuctions
+    expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
 
-      // approve first
-      const approveTx = approve({
-        contract: erc721Contract,
-        to: marketplaceContract.address,
-        tokenId: nftTokenId,
-      });
+    // approve first
+    const approveTx = approve({
+      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 = createAuction({
-        contract: marketplaceContract,
-        assetContractAddress: erc721Contract.address,
-        tokenId: nftTokenId,
-        minimumBidAmount: "1",
-        buyoutBidAmount: "10",
-      });
-      const receipt = await sendAndConfirmTransaction({
-        transaction,
-        account: TEST_ACCOUNT_A,
-      });
+    const transaction = createAuction({
+      contract: marketplaceContract,
+      assetContractAddress: erc721Contract.address,
+      tokenId: nftTokenId,
+      minimumBidAmount: "1",
+      buyoutBidAmount: "10",
+    });
+    const receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
 
-      const listingEvents = parseEventLogs({
-        events: [newAuctionEvent()],
-        logs: receipt.logs,
-      });
+    const listingEvents = parseEventLogs({
+      events: [newAuctionEvent()],
+      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.auctionCreator).toBe(TEST_ACCOUNT_A.address);
-      expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
+    expect(listingEvent.args.auctionCreator).toBe(TEST_ACCOUNT_A.address);
+    expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
 
-      // at this point auctions should be 1
-      const auctionsAfter = await getAllAuctions({
-        contract: marketplaceContract,
-      });
-      expect(auctionsAfter.length).toBe(1);
-      // valid auctions should also be 1!
-      const validAuctions = await getAllValidAuctions({
-        contract: marketplaceContract,
-      });
-      expect(validAuctions.length).toBe(1);
-      // and totalauctions should be 1
-      expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
+    // at this point auctions should be 1
+    const auctionsAfter = await getAllAuctions({
+      contract: marketplaceContract,
+    });
+    expect(auctionsAfter.length).toBe(1);
+    // valid auctions should also be 1!
+    const validAuctions = await getAllValidAuctions({
+      contract: marketplaceContract,
+    });
+    expect(validAuctions.length).toBe(1);
+    // and totalauctions should be 1
+    expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
 
-      // explicitly retrieve the listing!
-      const listing = await getAuction({
-        contract: marketplaceContract,
-        auctionId: listingEvent.args.auctionId,
-      });
+    // explicitly retrieve the listing!
+    const listing = await getAuction({
+      contract: marketplaceContract,
+      auctionId: listingEvent.args.auctionId,
+    });
 
-      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.minimumBidCurrencyValue).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.minimumBidCurrencyValue).toMatchInlineSnapshot(`
     {
       "decimals": 18,
       "displayValue": "1",
@@ -165,7 +163,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       "value": 1000000000000000000n,
     }
   `);
-      expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
+    expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
     {
       "decimals": 18,
       "displayValue": "10",
@@ -174,7 +172,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       "value": 10000000000000000000n,
     }
   `);
-      expect(listing.asset).toMatchInlineSnapshot(`
+    expect(listing.asset).toMatchInlineSnapshot(`
     {
       "id": 0n,
       "metadata": {
@@ -186,73 +184,71 @@ describe.runIf(process.env.TW_SECRET_KEY)(
     }
   `);
 
-      // check for a winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
-          auctionId: listing.id,
-        }),
-      ).resolves.toBeUndefined();
+    // check for a winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toBeUndefined();
 
-      // invalid bid amount 1: 0 bid (0 is not allowed)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "0",
-          }),
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is zero]",
-      );
-      // invalid bid amount 2: 11 bid (over buyout)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "11",
-          }),
+    // invalid bid amount 1: 0 bid (0 is not allowed)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "0",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is above the buyout amount]",
-      );
-      // invalid bid amount 3: below minimum bid (but not 0)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "0.5",
-          }),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot("[Error: Bid amount is zero]");
+    // invalid bid amount 2: 11 bid (over buyout)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "11",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is below the minimum bid amount]",
-      );
-
-      // valid bid amount: "2"
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "2",
-          }),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is above the buyout amount]",
+    );
+    // invalid bid amount 3: below minimum bid (but not 0)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "0.5",
         }),
-      ).resolves.toBeDefined();
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is below the minimum bid amount]",
+    );
 
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
+    // valid bid amount: "2"
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
           auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "2",
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 2000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -267,54 +263,54 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       }
     `);
 
-      // invalid bid amount, above minimum but below existing winning bid
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "1.5",
-          }),
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is too low to outbid the existing winning bid]",
-      );
-
-      // invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            // 2 * 1.05 = 2.1, so 2.05 is invalid
-            bidAmount: "2.05",
-          }),
+    // invalid bid amount, above minimum but below existing winning bid
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "1.5",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is too low to outbid the existing winning bid]",
-      );
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is too low to outbid the existing winning bid]",
+    );
 
-      // actually outbid the winning bid
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "3",
-          }),
+    // invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          // 2 * 1.05 = 2.1, so 2.05 is invalid
+          bidAmount: "2.05",
         }),
-      ).resolves.toBeDefined();
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is too low to outbid the existing winning bid]",
+    );
 
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
+    // actually outbid the winning bid
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
           auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "3",
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 3000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -329,24 +325,24 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       }
     `);
 
-      // buyout auction
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: buyoutAuction({
-            contract: marketplaceContract,
-            auctionId: listing.id,
-          }),
-        }),
-      ).resolves.toBeDefined();
-
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
+    // buyout auction
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: buyoutAuction({
           contract: marketplaceContract,
           auctionId: listing.id,
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 10000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -360,6 +356,5 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         },
       }
     `);
-    });
-  },
-);
+  });
+});

package/src/extensions/marketplace/offers/offers.test.ts

@@ -31,7 +31,7 @@ import { getOffer } from "./read/getOffer.js";
 import { acceptOffer } from "./write/acceptOffer.js";
 import { makeOffer } from "./write/makeOffer.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)("Marketplace: Offers", () => {
+describe.skip("Marketplace: Offers", () => {
   let nftTokenId: bigint;
   let marketplaceContract: ThirdwebContract;
   let erc721Contract: ThirdwebContract;

package/src/extensions/modular/__generated__/BatchMetadataERC1155/write/uploadMetadata.ts

@@ -153,5 +153,6 @@ export function uploadMetadata(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/BatchMetadataERC721/write/uploadMetadata.ts

@@ -153,5 +153,6 @@ export function uploadMetadata(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC1155/write/beforeMintERC1155.ts

@@ -197,5 +197,6 @@ export function beforeMintERC1155(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC1155/write/onInstall.ts

@@ -138,5 +138,6 @@ export function onInstall(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC1155/write/onUninstall.ts

@@ -138,5 +138,6 @@ export function onUninstall(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC1155/write/setClaimConditionByTokenId.ts

@@ -203,5 +203,6 @@ export function setClaimConditionByTokenId(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC1155/write/setSaleConfig.ts

@@ -140,5 +140,6 @@ export function setSaleConfig(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC20/write/beforeMintERC20.ts

@@ -180,5 +180,6 @@ export function beforeMintERC20(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC20/write/onInstall.ts

@@ -138,5 +138,6 @@ export function onInstall(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC20/write/onUninstall.ts

@@ -138,5 +138,6 @@ export function onUninstall(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC20/write/setClaimCondition.ts

@@ -188,5 +188,6 @@ export function setClaimCondition(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC20/write/setSaleConfig.ts

@@ -140,5 +140,6 @@ export function setSaleConfig(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }

package/src/extensions/modular/__generated__/ClaimableERC721/write/beforeMintERC721.ts

@@ -195,5 +195,6 @@ export function beforeMintERC721(
       (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
   });
 }