thirdweb 5.64.0-nightly-cdb907f175f7472d1fb3dea6547d946514564085-20241023000322 → 5.64.0

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/mintAdditionalSupplyTo.ts

@@ -38,16 +38,10 @@ export function mintAdditionalSupplyTo(
   return MintTo.mintTo({
     contract: options.contract,
     asyncParams: async () => {
-      // we'll be re-using the exising token URI
-      const tokenUri = await URI.uri({
-        contract: options.contract,
-        tokenId: options.tokenId,
-      });
-
       return {
         to: options.to,
         tokenId: options.tokenId,
-        uri: tokenUri,
+        uri: "", // contract will maintain the existing token URI
         amount: options.supply,
       };
     },

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

@@ -1,90 +1,21 @@
+import {} 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 { getContract } from "../../../contract/contract.js";
-import { deployERC1155Contract } from "../../../extensions/prebuilts/deploy-erc1155.js";
-import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
-import { getNFTs } from "../read/getNFTs.js";
-import { mintAdditionalSupplyToBatch } from "./mintAdditionalSupplyToBatch.js";
-import { mintToBatch } from "./mintToBatch.js";
+import { optimizeMintBatchContent } from "./mintAdditionalSupplyToBatch.js";
 
-const chain = ANVIL_CHAIN;
-const client = TEST_CLIENT;
 const account = TEST_ACCOUNT_C;
 
-describe.runIf(process.env.TW_SECRET_KEY)(
-  "ERC1155 Edition: mintToBatch",
-  () => {
-    it("should mint multiple tokens in one tx", async () => {
-      const contract = getContract({
-        chain,
-        client,
-        address: await deployERC1155Contract({
-          chain,
-          client,
-          account,
-          type: "TokenERC1155",
-          params: {
-            name: "edition",
-            contractURI: TEST_CONTRACT_URI,
-          },
-        }),
-      });
-
-      await sendAndConfirmTransaction({
-        account,
-        transaction: mintToBatch({
-          contract,
-          to: account.address,
-          nfts: [
-            { metadata: { name: "token 0" }, supply: 1n },
-            { metadata: { name: "token 1" }, supply: 2n },
-            { metadata: { name: "token 2" }, supply: 3n },
-          ],
-        }),
-      });
-
-      await sendAndConfirmTransaction({
-        account,
-        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 },
-          ],
-        }),
-      });
-
-      const nfts = await getNFTs({ contract });
-      expect(nfts).toStrictEqual([
-        {
-          metadata: { name: "token 0" },
-          owner: null,
-          id: 0n,
-          tokenURI: "ipfs://QmPZ6LpGqMuFbHKTXrNW1NRNLHf1nrxS4dtoFqdZZTKvPX/0",
-          type: "ERC1155",
-          supply: 100n,
-        },
-        {
-          metadata: { name: "token 1" },
-          owner: null,
-          id: 1n,
-          tokenURI: "ipfs://QmRFPyc3yEYxR4pQxwyTQWTine51TxWCoD6nzJWR3eX45b/0",
-          type: "ERC1155",
-          supply: 100n,
-        },
-        {
-          metadata: { name: "token 2" },
-          owner: null,
-          id: 2n,
-          tokenURI: "ipfs://QmesQiRLHCgqWZM2GFCs7Nb7rr2S72hU1BVQc7xiTyKZtT/0",
-          type: "ERC1155",
-          supply: 100n,
-        },
-      ]);
-    });
-  },
-);
+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

@@ -1,5 +1,8 @@
 import { multicall } from "../../../extensions/common/__generated__/IMulticall/write/multicall.js";
-import type { BaseTransactionOptions } from "../../../transaction/types.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";
@@ -7,9 +10,9 @@ import type { MintAdditionalSupplyToParams } from "./mintAdditionalSupplyTo.js";
 /**
  * @extension ERC1155
  */
-export type MintAdditionalSupplyToBatchParams = {
+export type MintAdditionalSupplyToBatchParams = WithOverrides<{
   nfts: MintAdditionalSupplyToParams[];
-};
+}>;
 
 /**
  * This extension batches multiple `mintAdditionalSupplyToBatch` extensions into one single multicall.
@@ -38,8 +41,9 @@ export function mintAdditionalSupplyToBatch(
   return multicall({
     contract: options.contract,
     asyncParams: async () => {
+      const nfts = optimizeMintBatchContent(options.nfts);
       const data = await Promise.all(
-        options.nfts.map(async (nft) => {
+        nfts.map(async (nft) => {
           const tokenUri = await uri({
             contract: options.contract,
             tokenId: nft.tokenId,
@@ -54,5 +58,48 @@ export function mintAdditionalSupplyToBatch(
       );
       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/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());
+  });
+});