thirdweb 5.63.3-nightly-50f98d7486809c541252a9cfc6979d102960366b-20241022000337 → 5.64.0-nightly-e6e994479fb8386b1740de4170f33446f038f2b1-20241024000332

package/src/extensions/erc1155/token1155.test.ts

@@ -1,3 +1,4 @@
+import { type Abi, toFunctionSelector } from "viem";
 import { beforeAll, describe, expect, it } from "vitest";
 import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
 import { ANVIL_CHAIN } from "../../../test/src/chains.js";
@@ -5,17 +6,27 @@ 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 { resolveContractAbi } from "../../contract/actions/resolve-abi.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { deployERC1155Contract } from "../prebuilts/deploy-erc1155.js";
 import { balanceOf } from "./__generated__/IERC1155/read/balanceOf.js";
 import { totalSupply } from "./__generated__/IERC1155/read/totalSupply.js";
+import { uri } from "./__generated__/IERC1155/read/uri.js";
 import { nextTokenIdToMint } from "./__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
 import { getNFT } from "./read/getNFT.js";
-import { getNFTs } from "./read/getNFTs.js";
-import { mintAdditionalSupplyTo } from "./write/mintAdditionalSupplyTo.js";
+import { getNFTs, isGetNFTsSupported } from "./read/getNFTs.js";
+import { getOwnedTokenIds } from "./read/getOwnedTokenIds.js";
+import {
+  isMintAdditionalSupplyToSupported,
+  mintAdditionalSupplyTo,
+} from "./write/mintAdditionalSupplyTo.js";
+import { mintAdditionalSupplyToBatch } from "./write/mintAdditionalSupplyToBatch.js";
 import { mintTo } from "./write/mintTo.js";
+import { mintToBatch } from "./write/mintToBatch.js";
+import { updateTokenURI } from "./write/updateTokenURI.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
   let contract: ThirdwebContract;
@@ -158,4 +169,161 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
       ]
     `);
   });
+
+  it("isGetNFTsSupported should work with our Edition contracts", async () => {
+    const abi = await resolveContractAbi<Abi>(contract);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isGetNFTsSupported(selectors)).toBe(true);
+  });
+
+  // tokenId #0 is updated in this test
+  it("should update tokenURI", async () => {
+    await sendAndConfirmTransaction({
+      transaction: updateTokenURI({
+        contract,
+        newMetadata: { name: "Test1 Updated" },
+        tokenId: 0n,
+      }),
+      account: TEST_ACCOUNT_A,
+    });
+    const nft = await getNFT({ contract, tokenId: 0n });
+    expect(nft.metadata.name).toBe("Test1 Updated");
+  });
+
+  it("should mint with `nft` being declared as a string", async () => {
+    await sendAndConfirmTransaction({
+      transaction: mintTo({
+        contract,
+        nft: TEST_CONTRACT_URI,
+        to: TEST_ACCOUNT_A.address,
+        supply: 1n,
+      }),
+      account: TEST_ACCOUNT_A,
+    });
+
+    const tokenUri = await uri({ contract, tokenId: 2n });
+    expect(tokenUri).toBe(TEST_CONTRACT_URI);
+  });
+
+  it("`isMintAdditionalSupplyToSupported` should work with our Edition contracts", async () => {
+    const abi = await resolveContractAbi<Abi>(contract);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isMintAdditionalSupplyToSupported(selectors)).toBe(true);
+  });
+
+  it("should mint multiple tokens in one tx", async () => {
+    await sendAndConfirmTransaction({
+      account: TEST_ACCOUNT_A,
+      transaction: mintToBatch({
+        contract,
+        to: TEST_ACCOUNT_C.address,
+        nfts: [
+          { metadata: { name: "batch token 0" }, supply: 1n },
+          { metadata: { name: "batch token 1" }, supply: 2n },
+          { metadata: { name: "batch token 2" }, supply: 3n },
+        ],
+      }),
+    });
+
+    const nfts = await getNFTs({ contract });
+    expect(nfts).toStrictEqual([
+      {
+        // Updated tokenURI from the test above
+        metadata: { name: "Test1 Updated" },
+        owner: null,
+        id: 0n,
+        tokenURI: "ipfs://QmTSyt6YgoFtH8yhWgevC22BxjyrkCKuzdk86nqQJCwrV9/0",
+        type: "ERC1155",
+        supply: 15n,
+      },
+      {
+        metadata: { name: "Test NFT 2" },
+        owner: null,
+        id: 1n,
+        tokenURI: "ipfs://QmV6gsfzdiMRtpnh8ay3CgutStVbes7qoF4DKpYE64h8hT/0",
+        type: "ERC1155",
+        supply: 5n,
+      },
+      {
+        metadata: {
+          name: "tw-contract-name",
+          symbol: "tw-contract-symbol",
+          description: "tw-contract-description",
+        },
+        owner: null,
+        id: 2n,
+        // Minted using URI from the test above
+        tokenURI:
+          "ipfs://bafybeiewg2e3vehsb5pb34xwk25eyyfwlvajzmgz3rtdrvn3upsxnsbhzi/contractUri.json",
+        type: "ERC1155",
+        supply: 1n,
+      },
+      {
+        metadata: { name: "batch token 0" },
+        owner: null,
+        id: 3n,
+        tokenURI: "ipfs://QmPSQhC2J6Wig4pH1Lt5th19FM58J5oukhfLfpc9L1i39Q/0",
+        type: "ERC1155",
+        supply: 1n,
+      },
+      {
+        metadata: { name: "batch token 1" },
+        owner: null,
+        id: 4n,
+        tokenURI: "ipfs://QmWRQwLBAeq6Wr65Yj7A4aeYqMD1C7Hs1moz15ncS6EhGu/0",
+        type: "ERC1155",
+        supply: 2n,
+      },
+      {
+        metadata: { name: "batch token 2" },
+        owner: null,
+        id: 5n,
+        tokenURI: "ipfs://QmTg1wxKGvdZR4NrdkYZGcfB5YYaBz75DH83td5RwprMRP/0",
+        type: "ERC1155",
+        supply: 3n,
+      },
+    ]);
+  });
+
+  it("getOwnedTokenIds should work", async () => {
+    const ownedTokenIds = await getOwnedTokenIds({
+      contract,
+      address: TEST_ACCOUNT_C.address,
+    });
+    expect(ownedTokenIds).toStrictEqual([
+      { tokenId: 3n, balance: 1n },
+      { tokenId: 4n, balance: 2n },
+      { tokenId: 5n, balance: 3n },
+    ]);
+  });
+
+  it("should mint multiple ADDITIONAL tokens in one tx", async () => {
+    await sendAndConfirmTransaction({
+      account: TEST_ACCOUNT_A,
+      transaction: mintAdditionalSupplyToBatch({
+        contract,
+        nfts: [
+          { tokenId: 3n, supply: 99n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 4n, supply: 94n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 5n, supply: 97n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 3n, supply: 4n, to: TEST_ACCOUNT_C.address },
+        ],
+      }),
+    });
+
+    const ownedTokenIds = await getOwnedTokenIds({
+      contract,
+      address: TEST_ACCOUNT_C.address,
+    });
+
+    expect(ownedTokenIds).toStrictEqual([
+      { tokenId: 3n, balance: 104n },
+      { tokenId: 4n, balance: 96n },
+      { tokenId: 5n, balance: 100n },
+    ]);
+  });
 });

package/src/extensions/erc1155/write/lazyMint.test.ts

@@ -1,32 +1,12 @@
 import { type Abi, toFunctionSelector } from "viem";
 import { describe, expect, it } from "vitest";
-import { ANVIL_CHAIN } from "~test/chains.js";
-import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
-import { TEST_CLIENT } from "~test/test-clients.js";
-import { TEST_ACCOUNT_C } from "~test/test-wallets.js";
+import { DROP1155_CONTRACT } from "~test/test-contracts.js";
 import { resolveContractAbi } from "../../../contract/actions/resolve-abi.js";
-import { getContract } from "../../../contract/contract.js";
-import { deployERC1155Contract } from "../../../extensions/prebuilts/deploy-erc1155.js";
 import { isLazyMintSupported } from "./lazyMint.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("erc1155: lazyMint", () => {
   it("`isLazyMintSupported` should work with our Edition Drop contracts", async () => {
-    const contract = getContract({
-      address: await deployERC1155Contract({
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "",
-          contractURI: TEST_CONTRACT_URI,
-        },
-        type: "DropERC1155",
-        account: TEST_ACCOUNT_C,
-      }),
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-    });
-
-    const abi = await resolveContractAbi<Abi>(contract);
+    const abi = await resolveContractAbi<Abi>(DROP1155_CONTRACT);
     const selectors = abi
       .filter((f) => f.type === "function")
       .map((f) => toFunctionSelector(f));

package/src/extensions/erc1155/write/mintAdditionalSupplyToBatch.test.ts

@@ -0,0 +1,21 @@
+import {} from "viem";
+import { describe, expect, it } from "vitest";
+import { TEST_ACCOUNT_C } from "~test/test-wallets.js";
+import { optimizeMintBatchContent } from "./mintAdditionalSupplyToBatch.js";
+
+const account = TEST_ACCOUNT_C;
+
+describe("ERC1155 Edition: mintToBatch", () => {
+  it("should optimize the mint content", () => {
+    expect(
+      optimizeMintBatchContent([
+        { tokenId: 0n, supply: 99n, to: account.address },
+        { tokenId: 1n, supply: 49n, to: account.address },
+        { tokenId: 1n, supply: 51n, to: account.address },
+      ]),
+    ).toStrictEqual([
+      { tokenId: 0n, supply: 99n, to: account.address },
+      { tokenId: 1n, supply: 100n, to: account.address },
+    ]);
+  });
+});

package/src/extensions/erc1155/write/mintAdditionalSupplyToBatch.ts

@@ -0,0 +1,105 @@
+import { multicall } from "../../../extensions/common/__generated__/IMulticall/write/multicall.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../transaction/types.js";
+import { uri } from "../__generated__/IERC1155/read/uri.js";
+import { encodeMintTo } from "../__generated__/IMintableERC1155/write/mintTo.js";
+import type { MintAdditionalSupplyToParams } from "./mintAdditionalSupplyTo.js";
+
+/**
+ * @extension ERC1155
+ */
+export type MintAdditionalSupplyToBatchParams = WithOverrides<{
+  nfts: MintAdditionalSupplyToParams[];
+}>;
+
+/**
+ * This extension batches multiple `mintAdditionalSupplyToBatch` extensions into one single multicall.
+ * Keep in mind that there is a limit of how many NFTs you can mint per transaction.
+ * This limit varies depends on the network that you are transacting on.
+ *
+ * You are recommended to experiment with the number to figure out the best number for your chain of choice.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { mintAdditionalSupplyToBatch } from "thirdweb/extensions/erc1155";
+ *
+ * const transaction = mintAdditionalSupplyToBatch({
+ *   contract,
+ *   nfts: [
+ *     { tokenId: 0n, supply: 99n, to: account.address },
+ *     { tokenId: 1n, supply: 98n, to: account.address },
+ *     { tokenId: 2n, supply: 97n, to: account.address },
+ *   ],
+ * });
+ * ```
+ */
+export function mintAdditionalSupplyToBatch(
+  options: BaseTransactionOptions<MintAdditionalSupplyToBatchParams>,
+) {
+  return multicall({
+    contract: options.contract,
+    asyncParams: async () => {
+      const nfts = optimizeMintBatchContent(options.nfts);
+      const data = await Promise.all(
+        nfts.map(async (nft) => {
+          const tokenUri = await uri({
+            contract: options.contract,
+            tokenId: nft.tokenId,
+          });
+          return encodeMintTo({
+            to: nft.to,
+            tokenId: nft.tokenId,
+            amount: nft.supply,
+            uri: tokenUri,
+          });
+        }),
+      );
+      return { data };
+    },
+    overrides: options.overrides,
+  });
+}
+
+/**
+ * Optimization
+ *
+ * We can batch the records that share the same "to" & "tokenId" into 1 transaction
+ *
+ * For example, this struct:
+ * [
+ *   { tokenId: 0n, supply: 99n, to: account.address },
+ *   { tokenId: 1n, supply: 49n, to: account.address },
+ *   { tokenId: 1n, supply: 51n, to: account.address },
+ * ]
+ *
+ * ...can be packed into:
+ * [
+ *   { tokenId: 0n, supply: 99n, to: account.address },
+ *   { tokenId: 1n, supply: 100n, to: account.address },
+ * ]
+ * @internal
+ */
+export function optimizeMintBatchContent(
+  nfts: MintAdditionalSupplyToParams[],
+): MintAdditionalSupplyToParams[] {
+  const results: MintAdditionalSupplyToParams[] = [];
+  for (const item of nfts) {
+    const matchingIndex = results.findIndex(
+      (o) =>
+        o.tokenId === item.tokenId &&
+        o.to.toLowerCase() === item.to.toLowerCase(),
+    );
+    if (matchingIndex !== -1) {
+      results[matchingIndex] = {
+        to: item.to,
+        tokenId: item.tokenId,
+        supply: item.supply + (results[matchingIndex]?.supply || 0n),
+      };
+    } else {
+      results.push(item);
+    }
+  }
+  return results;
+}

package/src/extensions/erc1155/write/mintToBatch.ts

@@ -83,33 +83,24 @@ export function mintToBatch(
   return multicall({
     contract: options.contract,
     asyncParams: async () => {
-      const uris = await Promise.all(
-        options.nfts.map((item) => {
-          if (typeof item.metadata === "string") {
-            return item.metadata;
-          }
-          return upload({
-            client: options.contract.client,
-            files: [item.metadata],
+      const data = await Promise.all(
+        options.nfts.map(async (nft) => {
+          const uri =
+            typeof nft.metadata === "string"
+              ? nft.metadata
+              : await upload({
+                  client: options.contract.client,
+                  files: [nft.metadata],
+                });
+          return encodeMintTo({
+            to: options.to,
+            // maxUint256 is used to indicate that this is a NEW token!
+            tokenId: maxUint256,
+            uri,
+            amount: nft.supply,
           });
         }),
       );
-
-      const data = uris.map((uri, index) => {
-        const item = options.nfts[index];
-        if (!item) {
-          // Should not happen
-          throw new Error("Index mismatch");
-        }
-        return encodeMintTo({
-          to: options.to,
-          // maxUint256 is used to indicate that this is a NEW token!
-          tokenId: maxUint256,
-          uri,
-          amount: item.supply,
-        });
-      });
-
       return { data };
     },
     overrides: options.overrides,

package/src/extensions/erc721/drops/write/claimTo.test.ts

@@ -0,0 +1,15 @@
+import { type Abi, toFunctionSelector } from "viem";
+import { describe, expect, it } from "vitest";
+import { NFT_DROP_CONTRACT } from "~test/test-contracts.js";
+import { resolveContractAbi } from "../../../../contract/actions/resolve-abi.js";
+import { isClaimToSupported } from "./claimTo.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("ERC721: claimTo", () => {
+  it("isClaimToSupported should work", async () => {
+    const abi = await resolveContractAbi<Abi>(NFT_DROP_CONTRACT);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isClaimToSupported(selectors)).toBe(true);
+  });
+});

package/src/extensions/erc721/drops/write/claimToBatch.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import {
+  TEST_ACCOUNT_A,
+  TEST_ACCOUNT_B,
+  TEST_ACCOUNT_C,
+  TEST_ACCOUNT_D,
+} from "~test/test-wallets.js";
+import { getContract } from "../../../../contract/contract.js";
+import { deployERC721Contract } from "../../../../extensions/prebuilts/deploy-erc721.js";
+import { sendAndConfirmTransaction } from "../../../../transaction/actions/send-and-confirm-transaction.js";
+import { getNFTs } from "../../read/getNFTs.js";
+import { lazyMint } from "../../write/lazyMint.js";
+import { claimToBatch, optimizeClaimContent } from "./claimToBatch.js";
+import { setClaimConditions } from "./setClaimConditions.js";
+
+const chain = ANVIL_CHAIN;
+const client = TEST_CLIENT;
+const account = TEST_ACCOUNT_A;
+
+describe.runIf(process.env.TW_SECRET_KEY)("erc721: claimToBatch", () => {
+  it("should optimize the claim content", () => {
+    expect(
+      optimizeClaimContent([
+        {
+          to: account.address,
+          quantity: 1n,
+        },
+        {
+          to: TEST_ACCOUNT_B.address,
+          quantity: 2n,
+        },
+        {
+          to: TEST_ACCOUNT_B.address,
+          quantity: 3n,
+        },
+        { to: TEST_ACCOUNT_C.address, quantity: 2n },
+        { to: TEST_ACCOUNT_D.address, quantity: 2n },
+        { to: account.address, quantity: 1n },
+      ]),
+    ).toStrictEqual([
+      { to: account.address, quantity: 1n },
+      { to: TEST_ACCOUNT_B.address, quantity: 5n },
+      { to: TEST_ACCOUNT_C.address, quantity: 2n },
+      { to: TEST_ACCOUNT_D.address, quantity: 2n },
+      { to: account.address, quantity: 1n },
+    ]);
+  });
+
+  it("should claim in batch", async () => {
+    const address = await deployERC721Contract({
+      account,
+      chain,
+      client,
+      params: {
+        name: "Test DropERC721",
+        contractURI: TEST_CONTRACT_URI,
+      },
+      type: "DropERC721",
+    });
+
+    const contract = getContract({
+      address,
+      chain,
+      client,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: lazyMint({
+        contract,
+        nfts: [
+          { name: "Test NFT 0" },
+          { name: "Test NFT 1" },
+          { name: "Test NFT 2" },
+          { name: "Test NFT 3" },
+          { name: "Test NFT 4" },
+          { name: "Test NFT 5" },
+          { name: "Test NFT 6" },
+          { name: "Test NFT 7" },
+          { name: "Test NFT 8" },
+          { name: "Test NFT 9" },
+          { name: "Test NFT 10" },
+        ],
+      }),
+      account,
+    });
+
+    await sendAndConfirmTransaction({
+      transaction: setClaimConditions({
+        contract,
+        phases: [{}],
+      }),
+      account: TEST_ACCOUNT_A,
+    });
+
+    const transaction = claimToBatch({
+      contract,
+      from: account.address,
+      content: [
+        {
+          to: account.address,
+          quantity: 1n,
+        },
+        {
+          to: TEST_ACCOUNT_B.address,
+          quantity: 2n,
+        },
+        {
+          to: TEST_ACCOUNT_B.address,
+          quantity: 3n,
+        },
+        { to: TEST_ACCOUNT_C.address, quantity: 2n },
+        { to: TEST_ACCOUNT_D.address, quantity: 2n },
+        { to: account.address, quantity: 1n },
+      ],
+    });
+
+    await sendAndConfirmTransaction({ account, transaction });
+
+    const nfts = await getNFTs({ contract, includeOwners: true });
+    expect(nfts.length).toBe(11);
+    expect(nfts[0]?.owner?.toLowerCase()).toBe(account.address.toLowerCase());
+    expect(nfts[1]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_B.address.toLowerCase(),
+    );
+    expect(nfts[2]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_B.address.toLowerCase(),
+    );
+    expect(nfts[3]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_B.address.toLowerCase(),
+    );
+    expect(nfts[4]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_B.address.toLowerCase(),
+    );
+    expect(nfts[5]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_B.address.toLowerCase(),
+    );
+    expect(nfts[6]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_C.address.toLowerCase(),
+    );
+    expect(nfts[7]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_C.address.toLowerCase(),
+    );
+    expect(nfts[8]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_D.address.toLowerCase(),
+    );
+    expect(nfts[9]?.owner?.toLowerCase()).toBe(
+      TEST_ACCOUNT_D.address.toLowerCase(),
+    );
+    expect(nfts[10]?.owner?.toLowerCase()).toBe(account.address.toLowerCase());
+  });
+});