Get events from insight (#6683)

Co-authored-by: Joaquim Verges <[email protected]>

Author: kumaryash90

.changeset/ready-tigers-pump.md

@@ -0,0 +1,32 @@
+---
+"thirdweb": patch
+---
+
+Get indexed events from `getContractEvents`
+
+You can now automatically query indexed events on supported chains when calling getContractEvents
+
+```ts
+import { getContractEvents } from "thirdweb";
+
+const events = await getContractEvents({
+  contract: DOODLES_CONTRACT,
+  events: [transferEvent()],
+});
+```
+
+This method falls back to RPC eth_getLogs if the indexer is not available.
+
+You can also use the dedicated indexer function via the Insight export
+
+```ts
+import { Insight } from "thirdweb";
+
+const events = await Insight.getContractEvents({
+  client,
+  chains: [sepolia],
+  contractAddress: "0x1234567890123456789012345678901234567890",
+  event: transferEvent(),
+  decodeLogs: true,
+});
+```

apps/dashboard/src/app/(dashboard)/(chain)/[chain_id]/[contractAddress]/cross-chain/page.tsx

@@ -2,7 +2,6 @@ import { fetchPublishedContractsFromDeploy } from "components/contract-component
 import { notFound } from "next/navigation";
 import {
   type ContractOptions,
-  eth_blockNumber,
   eth_getTransactionByHash,
   eth_getTransactionReceipt,
   getContractEvents,
@@ -39,14 +38,17 @@ export default async function Page(props: {
     chain_id: string;
   }>;
 }) {
+  const params = await props.params;
+  const info = await getContractPageParamsInfo(params);
+
   const ProxyDeployedEvent = prepareEvent({
     signature:
       "event ProxyDeployedV2(address indexed implementation, address indexed proxy, address indexed deployer, bytes32 inputSalt, bytes data, bytes extraData)",
+    filters: {
+      proxy: params.contractAddress.toLowerCase(),
+    },
   });
 
-  const params = await props.params;
-  const info = await getContractPageParamsInfo(params);
-
   if (!info) {
     notFound();
   }
@@ -111,16 +113,9 @@ export default async function Page(props: {
   let creationBlockNumber: bigint | undefined;
 
   if (twCloneFactoryContract) {
-    const latestBlockNumber = await eth_blockNumber(
-      getRpcClient({
-        client: contract.client,
-        chain: contract.chain,
-      }),
-    );
     const events = await getContractEvents({
       contract: twCloneFactoryContract,
       events: [ProxyDeployedEvent],
-      blockRange: latestBlockNumber < 100000n ? latestBlockNumber : 100000n,
     });
     const event = events.find(
       (e) =>
@@ -208,7 +203,6 @@ export default async function Page(props: {
       const events = await getContractEvents({
         contract: contract,
         events: [moduleEvent],
-        blockRange: 123456n,
       });
 
       const filteredEvents = events.filter(

packages/thirdweb/.size-limit.json

@@ -8,7 +8,7 @@
   {
     "name": "thirdweb (cjs)",
     "path": "./dist/cjs/exports/thirdweb.js",
-    "limit": "140 kB"
+    "limit": "150 kB"
   },
   {
     "name": "thirdweb (minimal + tree-shaking)",

packages/thirdweb/src/chains/types.ts

@@ -88,6 +88,14 @@ export type ChainMetadata = {
   stackType: string;
 };
 
+/**
+ * @chain
+ */
+export type ChainService = {
+  service: string;
+  enabled: boolean;
+};
+
 /**
  * @chain
  */

packages/thirdweb/src/chains/utils.ts

@@ -7,6 +7,7 @@ import type {
   Chain,
   ChainMetadata,
   ChainOptions,
+  ChainService,
   LegacyChain,
 } from "./types.js";
 
@@ -321,6 +322,66 @@ export function getChainMetadata(chain: Chain): Promise<ChainMetadata> {
   );
 }
 
+type FetchChainServiceResponse =
+  | {
+      data: {
+        services: ChainService[];
+      };
+      error?: never;
+    }
+  | {
+      data?: never;
+      error: unknown;
+    };
+
+/**
+ * Retrieves a list of services available on a given chain
+ * @param chain - The chain object containing the chain ID.
+ * @returns A Promise that resolves to chain services.
+ * @throws If there is an error fetching the chain services.
+ * @example
+ * ```ts
+ * const chain = defineChain({ id: 1 });
+ * const chainServices = await getChainServices(chain);
+ * console.log(chainServices);
+ * ```
+ * @chain
+ */
+export function getChainServices(chain: Chain): Promise<ChainService[]> {
+  const chainId = chain.id;
+  return withCache(
+    async () => {
+      try {
+        const res = await fetch(
+          `https://api.thirdweb.com/v1/chains/${chainId}/services`,
+        );
+        if (!res.ok) {
+          res.body?.cancel();
+          throw new Error(`Failed to fetch services for chainId ${chainId}`);
+        }
+
+        const response = (await res.json()) as FetchChainServiceResponse;
+        if (response.error) {
+          throw new Error(`Failed to fetch services for chainId ${chainId}`);
+        }
+        if (!response.data) {
+          throw new Error(`Failed to fetch services for chainId ${chainId}`);
+        }
+
+        const services = response.data.services;
+
+        return services;
+      } catch {
+        throw new Error(`Failed to fetch services for chainId ${chainId}`);
+      }
+    },
+    {
+      cacheKey: `chain:${chainId}:services`,
+      cacheTime: 24 * 60 * 60 * 1000, // 1 day
+    },
+  );
+}
+
 /**
  * Convert `ApiChain` to `Chain` object
  * @internal

packages/thirdweb/src/event/actions/get-events.test.ts

@@ -15,6 +15,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 10n,
+      useIndexer: false,
     });
     expect(events.length).toBe(261);
   });
@@ -35,13 +36,15 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: USDT_CONTRACT,
       blockRange: 10n,
+      useIndexer: false,
     });
     expect(events.length).toBe(241);
 
     const explicitEvents = await getContractEvents({
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 9n, // 1 less than range as fromBlock and toBlock are inclusive
       toBlock: FORK_BLOCK_NUMBER,
+      useIndexer: false,
     });
     expect(explicitEvents.length).toEqual(events.length);
   });
@@ -51,20 +54,23 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 49n,
       blockRange: 20n,
+      useIndexer: false,
     });
     expect(eventsFromBlock.length).toBe(412);
 
     const eventsToBlock = await getContractEvents({
       contract: USDT_CONTRACT,
       toBlock: FORK_BLOCK_NUMBER - 30n,
       blockRange: 20n,
+      useIndexer: false,
     });
     expect(eventsToBlock.length).toBe(eventsFromBlock.length);
 
     const explicitEvents = await getContractEvents({
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 49n,
       toBlock: FORK_BLOCK_NUMBER - 30n,
+      useIndexer: false,
     });
     expect(explicitEvents.length).toEqual(eventsFromBlock.length);
   });
@@ -73,6 +79,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 100n,
+      useIndexer: false,
       events: [
         prepareEvent({
           signature: "event Burn(address indexed burner, uint256 amount)",
@@ -86,6 +93,8 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: USDT_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 10n,
+      toBlock: FORK_BLOCK_NUMBER,
+      useIndexer: false,
       events: [
         prepareEvent({
           signature: "event Burn(address indexed burner, uint256 amount)",
@@ -126,6 +135,8 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: DOODLES_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 1000n,
+      toBlock: FORK_BLOCK_NUMBER,
+      useIndexer: false,
       events: [transferEvent()],
     });
     expect(events.length).toBe(38);
@@ -135,6 +146,8 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: DOODLES_CONTRACT,
       fromBlock: FORK_BLOCK_NUMBER - 1000n,
+      toBlock: FORK_BLOCK_NUMBER,
+      useIndexer: false,
       events: [
         transferEvent({
           from: "0xB81965DdFdDA3923f292a47A1be83ba3A36B5133",
@@ -143,4 +156,87 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     });
     expect(events.length).toBe(2);
   });
+
+  // insight tests
+
+  it("should get events for blockHash using indexer", async () => {
+    const BLOCK_HASH =
+      "0xb0ad5ee7b4912b50e5a2d7993796944653a4c0632c57740fe4a7a1c61e426324";
+    const events = await getContractEvents({
+      contract: USDT_CONTRACT,
+      blockHash: BLOCK_HASH,
+      useIndexer: true,
+    });
+
+    expect(events.length).toBe(14);
+  });
+
+  it("should get individual events with extension no filter using indexer", async () => {
+    const events = await getContractEvents({
+      contract: DOODLES_CONTRACT,
+      fromBlock: FORK_BLOCK_NUMBER - 1000n,
+      toBlock: FORK_BLOCK_NUMBER,
+      events: [transferEvent()],
+      useIndexer: true,
+    });
+    expect(events.length).toBe(38);
+  });
+
+  it("should get events for signature using indexer", async () => {
+    const events = await getContractEvents({
+      contract: DOODLES_CONTRACT,
+      fromBlock: FORK_BLOCK_NUMBER - 1000n,
+      toBlock: FORK_BLOCK_NUMBER,
+      events: [
+        transferEvent({
+          from: "0xB81965DdFdDA3923f292a47A1be83ba3A36B5133",
+        }),
+      ],
+      useIndexer: true,
+    });
+
+    expect(events.length).toBe(2);
+  });
+
+  it("should get specified events using indexer", async () => {
+    const events = await getContractEvents({
+      contract: USDT_CONTRACT,
+      fromBlock: FORK_BLOCK_NUMBER - 10n,
+      toBlock: FORK_BLOCK_NUMBER,
+      useIndexer: true,
+      events: [
+        prepareEvent({
+          signature: "event Burn(address indexed burner, uint256 amount)",
+        }),
+        prepareEvent({
+          signature: {
+            anonymous: false,
+            inputs: [
+              {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+              },
+              {
+                indexed: true,
+                internalType: "address",
+                name: "spender",
+                type: "address",
+              },
+              {
+                indexed: false,
+                internalType: "uint256",
+                name: "value",
+                type: "uint256",
+              },
+            ],
+            name: "Approval",
+            type: "event",
+          },
+        }),
+      ],
+    });
+    expect(events.length).toMatchInlineSnapshot("9");
+  });
 });