thirdweb 5.95.0-nightly-4c1f384a635054a8cfaaa487e3ba7ada63b221ec-20250415110008 → 5.95.0-nightly-e7b01108037ebef07fba95f888be1905c8fab5df-20250417000348

package/src/event/actions/get-events.ts

@@ -1,18 +1,13 @@
-/**
- * 1. blockTime + contract (with abi) + no events -> logs with types and parsing *if* contract has abi defined
- * 2. blockTime + contract (no abi) + no events -> logs with NO types but *with* parsing
- * 3. blockTime + no contract + events -> logs with types and parsing (across all "addresses") (no contract filter)
- * 4. blockTime + contract + events -> logs with types and parsing (filtered by contract address +  event topics)
- */
-
 import type {
   Abi,
   AbiEvent,
   ExtractAbiEvent,
   ExtractAbiEventNames,
 } from "abitype";
+import { type Log, formatLog } from "viem";
 import { resolveContractAbi } from "../../contract/actions/resolve-abi.js";
 import type { ThirdwebContract } from "../../contract/contract.js";
+import { getContractEvents as getContractEventsInsight } from "../../insight/get-events.js";
 import { eth_blockNumber } from "../../rpc/actions/eth_blockNumber.js";
 import {
   type GetLogsBlockParams,
@@ -21,6 +16,7 @@ import {
 } from "../../rpc/actions/eth_getLogs.js";
 import { getRpcClient } from "../../rpc/rpc.js";
 import { getAddress } from "../../utils/address.js";
+import { type Hex, numberToHex } from "../../utils/encoding/hex.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import { type PreparedEvent, prepareEvent } from "../prepare-event.js";
 import { isAbiEvent } from "../utils.js";
@@ -34,6 +30,7 @@ export type GetContractEventsOptionsDirect<
   contract: ThirdwebContract<abi>;
   events?: abiEvents;
   strict?: TStrict;
+  useIndexer?: boolean;
 };
 
 export type GetContractEventsOptions<
@@ -49,6 +46,10 @@ export type GetContractEventsResult<
   TStrict extends boolean,
 > = ParseEventLogsResult<abiEvents, TStrict>;
 
+type GetLogsParamsExtra = {
+  signature?: string;
+} & GetLogsParams;
+
 /**
  * Retrieves events from a contract based on the provided options.
  * @param options - The options for retrieving events.
@@ -106,7 +107,13 @@ export async function getContractEvents<
 >(
   options: GetContractEventsOptions<abi, abiEvents, TStrict>,
 ): Promise<GetContractEventsResult<abiEvents, TStrict>> {
-  const { contract, events, blockRange, ...restParams } = options;
+  const {
+    contract,
+    events,
+    blockRange,
+    useIndexer = true,
+    ...restParams
+  } = options;
 
   const rpcRequest = getRpcClient(contract);
 
@@ -164,7 +171,7 @@ export async function getContractEvents<
     }
   }
 
-  const logsParams: GetLogsParams[] =
+  const logsParams: GetLogsParamsExtra[] =
     events && events.length > 0
       ? // if we have events passed in then we use those
         events.map((e) => ({
@@ -175,9 +182,33 @@ export async function getContractEvents<
       : // otherwise we want "all" events (aka not pass any topics at all)
         [{ ...restParams, address: getAddress(contract.address) }];
 
-  const logs = await Promise.all(
-    logsParams.map((ethLogParams) => eth_getLogs(rpcRequest, ethLogParams)),
-  );
+  let logs: Log[][] = [];
+
+  // try fetching from insight if available
+  if (useIndexer) {
+    try {
+      logs = await Promise.all(
+        logsParams.map((p) =>
+          getLogsFromInsight({
+            params: p,
+            contract,
+          }),
+        ),
+      );
+    } catch (e) {
+      console.warn("Error fetching from insight, falling back to rpc", e);
+      // fetch from rpc
+      logs = await Promise.all(
+        logsParams.map((ethLogParams) => eth_getLogs(rpcRequest, ethLogParams)),
+      );
+    }
+  } else {
+    // fetch from rpc
+    logs = await Promise.all(
+      logsParams.map((ethLogParams) => eth_getLogs(rpcRequest, ethLogParams)),
+    );
+  }
+
   const flattenLogs = logs
     .flat()
     .sort((a, b) => Number((a.blockNumber ?? 0n) - (b.blockNumber ?? 0n)));
@@ -186,3 +217,47 @@ export async function getContractEvents<
     events: resolvedEvents,
   });
 }
+
+async function getLogsFromInsight(options: {
+  params: GetLogsParamsExtra;
+  contract: ThirdwebContract<Abi>;
+}): Promise<Log[]> {
+  const { params, contract } = options;
+
+  const fromBlock =
+    typeof params.fromBlock === "bigint" ? Number(params.fromBlock) : undefined;
+
+  const toBlock =
+    typeof params.toBlock === "bigint" ? Number(params.toBlock) : undefined;
+
+  const r = await getContractEventsInsight({
+    client: contract.client,
+    chains: [contract.chain],
+    contractAddress: contract.address,
+    queryOptions: {
+      limit: 500,
+      filter_block_hash: params.blockHash,
+      filter_block_number_gte: fromBlock,
+      filter_block_number_lte: toBlock,
+      filter_topic_0: params.topics?.[0] as Hex | undefined,
+      filter_topic_1: params.topics?.[1] as Hex | undefined,
+      filter_topic_2: params.topics?.[2] as Hex | undefined,
+      filter_topic_3: params.topics?.[3] as Hex | undefined,
+    },
+  });
+
+  const cleanedEventData = r.map((tx) => ({
+    chainId: tx.chain_id,
+    blockNumber: numberToHex(Number(tx.block_number)),
+    blockHash: tx.block_hash as Hex,
+    blockTimestamp: tx.block_timestamp,
+    transactionHash: tx.transaction_hash as Hex,
+    transactionIndex: numberToHex(tx.transaction_index),
+    logIndex: numberToHex(tx.log_index),
+    address: tx.address,
+    data: tx.data as Hex,
+    topics: tx.topics as [`0x${string}`, ...`0x${string}`[]] | [] | undefined,
+  }));
+
+  return cleanedEventData.map((e) => formatLog(e));
+}

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

@@ -11,6 +11,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc1155.getNFT", () => {
     });
     expect(nft).toMatchInlineSnapshot(`
       {
+        "chainId": 1,
         "id": 2n,
         "metadata": {
           "animation_url": "ipfs://QmYoM63qaumQznBRx38tQjkY4ewbymeFb2KWBhkfMqNHax/3.mp4",
@@ -36,6 +37,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc1155.getNFT", () => {
         },
         "owner": null,
         "supply": 2519n,
+        "tokenAddress": "0x42d3641255C946CC451474295d29D3505173F22A",
         "tokenURI": "ipfs://QmbMXdbnNUAuGRoY6c6G792c6T9utfaBGqRUaMaRUf52Cb/2",
         "type": "ERC1155",
       }

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

@@ -58,6 +58,8 @@ export async function getNFT(
       type: "ERC1155",
       owner: null,
       supply,
+      tokenAddress: options.contract.address,
+      chainId: options.contract.chain.id,
     },
   );
 }

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,118 @@ 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");
+    // TODO (insight): re-enable once insight fixes the client id caching issue
+    // 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": "https://${clientId}.ipfscdn.io/ipfs/QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+    //       "image_url": "https://${clientId}.ipfscdn.io/ipfs/QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+    //       "name": "Doodle #1",
+    //       "uri": "https://${clientId}.ipfscdn.io/ipfs/QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+    //     },
+    //     "owner": null,
+    //     "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
+    //     "tokenURI": "https://${clientId}.ipfscdn.io/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");
+    // TODO (insight): re-enable once insight fixes the client id caching issue
+    // 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": "https://${clientId}.ipfscdn.io/ipfs/QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+    //       "image_url": "https://${clientId}.ipfscdn.io/ipfs/QmTDxnzcvj2p3xBrKcGv1wxoyhAn2yzCQnZZ9LmFjReuH9",
+    //       "name": "Doodle #1",
+    //       "owner_addresses": [
+    //         "0xbe9936fcfc50666f5425fde4a9decc59cef73b24",
+    //       ],
+    //       "uri": "https://${clientId}.ipfscdn.io/ipfs/QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
+    //     },
+    //     "owner": "0xbe9936fcfc50666f5425fde4a9decc59cef73b24",
+    //     "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
+    //     "tokenURI": "https://${clientId}.ipfscdn.io/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 +144,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 +156,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 +190,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
           "name": "Doodle #1",
         },
         "owner": "0xbE9936FCFC50666f5425FDE4A9decC59cEF73b24",
+        "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
         "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
         "type": "ERC721",
       }