thirdweb 5.95.0-nightly-64bd603301b3067b6a69a29f66a28dee7ffa38f5-20250416000349 → 5.95.0-nightly-4cf15a2475fce1c5b55d19f7cf51ab080e80e33f-20250418000341

package/src/extensions/erc1155/read/getNFTs.ts

@@ -1,4 +1,5 @@
 import { maxUint256 } from "ox/Solidity";
+import { getContractNFTs } from "../../../insight/get-nfts.js";
 import type { BaseTransactionOptions } from "../../../transaction/types.js";
 import { min } from "../../../utils/bigint.js";
 import type { NFT } from "../../../utils/nft/parseNft.js";
@@ -23,6 +24,11 @@ export type GetNFTsParams = {
    * The number of NFTs to retrieve.
    */
   count?: number;
+  /**
+   * Whether to use the insight API to fetch the NFTs.
+   * @default true
+   */
+  useIndexer?: boolean;
 };
 
 /**
@@ -42,6 +48,38 @@ export type GetNFTsParams = {
  */
 export async function getNFTs(
   options: BaseTransactionOptions<GetNFTsParams>,
+): Promise<NFT[]> {
+  const { useIndexer = true } = options;
+  if (useIndexer) {
+    try {
+      return await getNFTsFromInsight(options);
+    } catch {
+      return await getNFTsFromRPC(options);
+    }
+  }
+  return await getNFTsFromRPC(options);
+}
+
+async function getNFTsFromInsight(
+  options: BaseTransactionOptions<GetNFTsParams>,
+): Promise<NFT[]> {
+  const { contract, start, count = Number(DEFAULT_QUERY_ALL_COUNT) } = options;
+
+  const result = await getContractNFTs({
+    client: contract.client,
+    chains: [contract.chain],
+    contractAddress: contract.address,
+    queryOptions: {
+      limit: count,
+      page: start ? Math.floor(start / count) : undefined,
+    },
+  });
+
+  return result;
+}
+
+async function getNFTsFromRPC(
+  options: BaseTransactionOptions<GetNFTsParams>,
 ): Promise<NFT[]> {
   const start = BigInt(options.start || 0);
   const count = BigInt(options.count || DEFAULT_QUERY_ALL_COUNT);

package/src/extensions/erc1155/read/getOwnedNFTs.ts

@@ -1,3 +1,4 @@
+import { getOwnedNFTs as getInsightNFTs } from "../../../insight/get-nfts.js";
 import type { BaseTransactionOptions } from "../../../transaction/types.js";
 import type { NFT } from "../../../utils/nft/parseNft.js";
 import { getNFT } from "./getNFT.js";
@@ -5,12 +6,17 @@ import {
   type GetOwnedTokenIdsParams,
   getOwnedTokenIds,
 } from "./getOwnedTokenIds.js";
-
 /**
  * Parameters for retrieving NFTs.
  * @extension ERC1155
  */
-export type GetOwnedNFTsParams = GetOwnedTokenIdsParams;
+export type GetOwnedNFTsParams = GetOwnedTokenIdsParams & {
+  /**
+   * Whether to use the insight API to fetch the NFTs.
+   * @default true
+   */
+  useIndexer?: boolean;
+};
 
 /**
  * Retrieves the owned ERC1155 NFTs for a given wallet address.
@@ -30,6 +36,63 @@ export type GetOwnedNFTsParams = GetOwnedTokenIdsParams;
  */
 export async function getOwnedNFTs(
   options: BaseTransactionOptions<GetOwnedNFTsParams>,
+): Promise<(NFT & { quantityOwned: bigint })[]> {
+  const { useIndexer = true } = options;
+  if (useIndexer) {
+    try {
+      return await getOwnedNFTsFromInsight(options);
+    } catch {
+      return await getOwnedNFTsFromRPC(options);
+    }
+  }
+  return await getOwnedNFTsFromRPC(options);
+}
+
+async function getOwnedNFTsFromInsight(
+  options: BaseTransactionOptions<GetOwnedNFTsParams>,
+): Promise<(NFT & { quantityOwned: bigint })[]> {
+  const limit = 50;
+  const nfts: (NFT & { quantityOwned: bigint })[] = [];
+  let page = 0;
+  let hasMore = true;
+
+  // TODO (insight): add support for contract address filters
+  while (hasMore) {
+    const pageResults = await getInsightNFTs({
+      client: options.contract.client,
+      chains: [options.contract.chain],
+      ownerAddress: options.address,
+      queryOptions: {
+        limit,
+        page,
+      },
+    });
+
+    nfts.push(...pageResults);
+
+    // If we got fewer results than the limit, we've reached the end
+    if (pageResults.length < limit) {
+      hasMore = false;
+    } else {
+      page++;
+    }
+  }
+
+  const results = nfts;
+
+  return results
+    .filter(
+      (n) =>
+        n.tokenAddress.toLowerCase() === options.contract.address.toLowerCase(),
+    )
+    .map((result) => ({
+      ...result,
+      owner: options.address,
+    }));
+}
+
+async function getOwnedNFTsFromRPC(
+  options: BaseTransactionOptions<GetOwnedNFTsParams>,
 ): Promise<(NFT & { quantityOwned: bigint })[]> {
   const ownedBalances = await getOwnedTokenIds(options);
 

package/src/extensions/erc20/drop20.test.ts

@@ -59,17 +59,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
     }, 60_000);
 
     it("should allow to claim tokens", async () => {
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "0",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 0n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+          .displayValue,
+      ).toBe("0");
       await sendAndConfirmTransaction({
         transaction: setClaimConditions({
           contract,
@@ -98,31 +91,17 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         transaction: claimTx,
         account: TEST_ACCOUNT_A,
       });
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "1",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 1000000000000000000n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+          .displayValue,
+      ).toBe("1");
     });
 
     it("should allow to claim tokens with value", async () => {
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_C.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "0",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 0n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_C.address }))
+          .displayValue,
+      ).toBe("0");
       // set cc with price
       await sendAndConfirmTransaction({
         transaction: setClaimConditions({
@@ -150,17 +129,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         transaction: claimTx,
         account: TEST_ACCOUNT_C,
       });
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_C.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "2",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 2000000000000000000n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_C.address }))
+          .displayValue,
+      ).toBe("2");
     });
 
     describe("Allowlists", () => {
@@ -181,17 +153,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           account: TEST_ACCOUNT_A,
         });
 
-        await expect(
-          getBalance({ contract, address: TEST_ACCOUNT_B.address }),
-        ).resolves.toMatchInlineSnapshot(`
-          {
-            "decimals": 18,
-            "displayValue": "0",
-            "name": "Test DropERC20",
-            "symbol": "",
-            "value": 0n,
-          }
-        `);
+        expect(
+          (await getBalance({ contract, address: TEST_ACCOUNT_B.address }))
+            .displayValue,
+        ).toBe("0");
 
         expect(
           await canClaim({
@@ -228,17 +193,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           }),
         });
 
-        await expect(
-          getBalance({ contract, address: TEST_ACCOUNT_B.address }),
-        ).resolves.toMatchInlineSnapshot(`
-          {
-            "decimals": 18,
-            "displayValue": "1",
-            "name": "Test DropERC20",
-            "symbol": "",
-            "value": 1000000000000000000n,
-          }
-        `);
+        expect(
+          (await getBalance({ contract, address: TEST_ACCOUNT_B.address }))
+            .displayValue,
+        ).toBe("1");
 
         await expect(
           sendAndConfirmTransaction({
@@ -274,17 +232,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           account: TEST_ACCOUNT_A,
         });
 
-        await expect(
-          getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-        ).resolves.toMatchInlineSnapshot(`
-          {
-            "decimals": 18,
-            "displayValue": "1",
-            "name": "Test DropERC20",
-            "symbol": "",
-            "value": 1000000000000000000n,
-          }
-        `);
+        expect(
+          (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+            .displayValue,
+        ).toBe("1");
 
         // we try to claim an extra `2` tokens
         // this should faile bcause the max claimable is `3` and we have previously already claimed 2 tokens (one for ourselves, one for the other wallet)
@@ -318,17 +269,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           }),
         });
 
-        await expect(
-          getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-        ).resolves.toMatchInlineSnapshot(`
-          {
-            "decimals": 18,
-            "displayValue": "2",
-            "name": "Test DropERC20",
-            "symbol": "",
-            "value": 2000000000000000000n,
-          }
-        `);
+        expect(
+          (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+            .displayValue,
+        ).toBe("2");
       });
     });
 
@@ -353,17 +297,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
       });
 
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "2",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 2000000000000000000n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+          .displayValue,
+      ).toBe("2");
 
       await sendAndConfirmTransaction({
         account: TEST_ACCOUNT_A,
@@ -374,17 +311,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         }),
       });
 
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_A.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "3",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 3000000000000000000n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_A.address }))
+          .displayValue,
+      ).toBe("3");
     });
 
     it("should be able to retrieve multiple phases", async () => {
@@ -436,17 +366,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_D,
       });
       // check that the account has claimed one token
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_D.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "0.000000000000000001",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 1n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_D.address }))
+          .displayValue,
+      ).toBe("0.000000000000000001");
 
       // attempt to claim another token (this should fail)
       await expect(
@@ -482,17 +405,10 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_D,
       });
       // check that the account has claimed two tokens
-      await expect(
-        getBalance({ contract, address: TEST_ACCOUNT_D.address }),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "decimals": 18,
-          "displayValue": "0.000000000000000002",
-          "name": "Test DropERC20",
-          "symbol": "",
-          "value": 2n,
-        }
-      `);
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_D.address }))
+          .displayValue,
+      ).toBe("0.000000000000000002");
     });
   },
 );

package/src/extensions/erc20/read/getBalance.test.ts

@@ -10,14 +10,10 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc20.getBalance", () => {
       contract: USDT_CONTRACT,
       address: VITALIK_WALLET,
     });
-    expect(balance).toMatchInlineSnapshot(`
-      {
-        "decimals": 6,
-        "displayValue": "1544.900798",
-        "name": "Tether USD",
-        "symbol": "USDT",
-        "value": 1544900798n,
-      }
-    `);
+    expect(balance.displayValue).toBe("1544.900798");
+    expect(balance.name).toBe("Tether USD");
+    expect(balance.symbol).toBe("USDT");
+    expect(balance.value).toBe(1544900798n);
+    expect(balance.decimals).toBe(6);
   });
 });

package/src/extensions/erc20/read/getBalance.ts

@@ -23,6 +23,8 @@ export type GetBalanceResult = {
   displayValue: string;
   symbol: string;
   name: string;
+  tokenAddress: string;
+  chainId: number;
 };
 
 /**
@@ -48,5 +50,7 @@ export async function getBalance(
     ...currencyMetadata,
     value: balanceWei,
     displayValue: toTokens(balanceWei, currencyMetadata.decimals),
+    tokenAddress: options.contract.address,
+    chainId: options.contract.chain.id,
   };
 }

package/src/extensions/erc721/read/getNFT.test.ts

@@ -3,14 +3,116 @@ import { DOODLES_CONTRACT } from "~test/test-contracts.js";
 import { getNFT } from "./getNFT.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
+  it("without owner using indexer", async () => {
+    const nft = await getNFT({
+      contract: DOODLES_CONTRACT,
+      tokenId: 1n,
+      includeOwner: false,
+    });
+    expect(nft.metadata.name).toBe("Doodle #1");
+    expect(nft).toMatchInlineSnapshot(`
+      {
+        "chainId": 1,
+        "id": 1n,
+        "metadata": {
+          "attributes": [
+            {
+              "trait_type": "face",
+              "value": "holographic beard",
+            },
+            {
+              "trait_type": "hair",
+              "value": "white bucket cap",
+            },
+            {
+              "trait_type": "body",
+              "value": "purple sweater with satchel",
+            },
+            {
+              "trait_type": "background",
+              "value": "grey",
+            },
+            {
+              "trait_type": "head",
+              "value": "gradient 2",
+            },
+          ],
+          "description": "A community-driven collectibles project featuring art by Burnt Toast. Doodles come in a joyful range of colors, traits and sizes with a collection size of 10,000. Each Doodle allows its owner to vote for experiences and activations paid for by the Doodles Community Treasury. Burnt Toast is the working alias for Scott Martin, a Canadian–based illustrator, designer, animator and muralist.",
+          "image": "ipfs://QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+          "image_url": "ipfs://QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+          "name": "Doodle #1",
+          "uri": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+        },
+        "owner": null,
+        "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
+        "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+        "type": "ERC721",
+      }
+    `);
+  });
+
+  it("with owner using indexer", async () => {
+    const nft = await getNFT({
+      contract: { ...DOODLES_CONTRACT },
+      tokenId: 1n,
+      includeOwner: true,
+    });
+    expect(nft.metadata.name).toBe("Doodle #1");
+    expect(nft.owner).toBe("0xbe9936fcfc50666f5425fde4a9decc59cef73b24");
+    expect(nft).toMatchInlineSnapshot(`
+      {
+        "chainId": 1,
+        "id": 1n,
+        "metadata": {
+          "attributes": [
+            {
+              "trait_type": "face",
+              "value": "holographic beard",
+            },
+            {
+              "trait_type": "hair",
+              "value": "white bucket cap",
+            },
+            {
+              "trait_type": "body",
+              "value": "purple sweater with satchel",
+            },
+            {
+              "trait_type": "background",
+              "value": "grey",
+            },
+            {
+              "trait_type": "head",
+              "value": "gradient 2",
+            },
+          ],
+          "description": "A community-driven collectibles project featuring art by Burnt Toast. Doodles come in a joyful range of colors, traits and sizes with a collection size of 10,000. Each Doodle allows its owner to vote for experiences and activations paid for by the Doodles Community Treasury. Burnt Toast is the working alias for Scott Martin, a Canadian–based illustrator, designer, animator and muralist.",
+          "image": "ipfs://QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+          "image_url": "ipfs://QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+          "name": "Doodle #1",
+          "owner_addresses": [
+            "0xbe9936fcfc50666f5425fde4a9decc59cef73b24",
+          ],
+          "uri": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+        },
+        "owner": "0xbe9936fcfc50666f5425fde4a9decc59cef73b24",
+        "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
+        "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+        "type": "ERC721",
+      }
+    `);
+  });
+
   it("without owner", async () => {
     const nft = await getNFT({
       contract: { ...DOODLES_CONTRACT },
       tokenId: 1n,
       includeOwner: false,
+      useIndexer: false,
     });
     expect(nft).toMatchInlineSnapshot(`
       {
+        "chainId": 1,
         "id": 1n,
         "metadata": {
           "attributes": [
@@ -40,6 +142,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
           "name": "Doodle #1",
         },
         "owner": null,
+        "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
         "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
         "type": "ERC721",
       }
@@ -51,9 +154,11 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
       contract: { ...DOODLES_CONTRACT },
       tokenId: 1n,
       includeOwner: true,
+      useIndexer: false,
     });
     expect(nft).toMatchInlineSnapshot(`
       {
+        "chainId": 1,
         "id": 1n,
         "metadata": {
           "attributes": [
@@ -83,6 +188,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
           "name": "Doodle #1",
         },
         "owner": "0xbE9936FCFC50666f5425FDE4A9decC59cEF73b24",
+        "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
         "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
         "type": "ERC721",
       }

package/src/extensions/erc721/read/getNFT.ts

@@ -7,8 +7,8 @@ import {
   tokenURI,
 } from "../__generated__/IERC721A/read/tokenURI.js";
 import { tokenByIndex } from "../__generated__/IERC721Enumerable/read/tokenByIndex.js";
-
 export { isTokenURISupported as isGetNFTSupported } from "../__generated__/IERC721A/read/tokenURI.js";
+import { getNFT as getNFTInsight } from "../../../insight/index.js";
 
 /**
  * Parameters for getting an NFT.
@@ -27,6 +27,11 @@ export type GetNFTParams = Prettify<
      * In this case, the provided tokenId will be considered as token-index and actual tokenId will be fetched from the contract.
      */
     tokenByIndex?: boolean;
+    /**
+     * Whether to use the insight API to fetch the NFT.
+     * @default true
+     */
+    useIndexer?: boolean;
   }
 >;
 
@@ -58,6 +63,51 @@ export type GetNFTParams = Prettify<
  */
 export async function getNFT(
   options: BaseTransactionOptions<GetNFTParams>,
+): Promise<NFT> {
+  const { useIndexer = true } = options;
+  if (useIndexer) {
+    try {
+      return await getNFTFromInsight(options);
+    } catch {
+      return await getNFTFromRPC(options);
+    }
+  }
+  return await getNFTFromRPC(options);
+}
+
+async function getNFTFromInsight(
+  options: BaseTransactionOptions<GetNFTParams>,
+): Promise<NFT> {
+  const tokenId = options.tokenId;
+  const nft = await getNFTInsight({
+    client: options.contract.client,
+    chain: options.contract.chain,
+    contractAddress: options.contract.address,
+    tokenId: options.tokenId,
+    includeOwners: options.includeOwner,
+  });
+  if (!nft) {
+    return parseNFT(
+      {
+        id: tokenId,
+        type: "ERC721",
+        uri: "",
+      },
+      {
+        tokenId,
+        tokenUri: "",
+        type: "ERC721",
+        owner: null,
+        tokenAddress: options.contract.address,
+        chainId: options.contract.chain.id,
+      },
+    );
+  }
+  return nft;
+}
+
+async function getNFTFromRPC(
+  options: BaseTransactionOptions<GetNFTParams>,
 ): Promise<NFT> {
   let tokenId = options.tokenId;
   if (options.tokenByIndex) {
@@ -90,6 +140,8 @@ export async function getNFT(
         tokenUri: "",
         type: "ERC721",
         owner,
+        tokenAddress: options.contract.address,
+        chainId: options.contract.chain.id,
       },
     );
   }
@@ -109,6 +161,8 @@ export async function getNFT(
       tokenUri: uri,
       type: "ERC721",
       owner,
+      tokenAddress: options.contract.address,
+      chainId: options.contract.chain.id,
     },
   );
 }