use insight client + fixes + tests

Author: joaquim-verges

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

@@ -93,6 +93,7 @@ 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({
@@ -134,6 +135,7 @@ 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()],
     });
@@ -144,6 +146,7 @@ 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({
@@ -154,6 +157,8 @@ 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";
@@ -165,4 +170,73 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
 
     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");
+  });
 });

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

@@ -1,22 +1,14 @@
-/**
- * 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 type { Chain } from "../../chains/types.js";
 import { getChainServices } from "../../chains/utils.js";
-import type { ThirdwebClient } from "../../client/client.js";
 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,
@@ -25,9 +17,7 @@ import {
 } from "../../rpc/actions/eth_getLogs.js";
 import { getRpcClient } from "../../rpc/rpc.js";
 import { getAddress } from "../../utils/address.js";
-import { getThirdwebDomains } from "../../utils/domains.js";
 import { type Hex, numberToHex } from "../../utils/encoding/hex.js";
-import { getClientFetch } from "../../utils/fetch.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import { type PreparedEvent, prepareEvent } from "../prepare-event.js";
 import { isAbiEvent } from "../utils.js";
@@ -189,7 +179,6 @@ export async function getContractEvents<
           ...restParams,
           address: getAddress(contract.address),
           topics: e.topics,
-          signature: `${e?.abiEvent.name}(${e?.abiEvent.inputs.map((i) => i.type).join(",")})`,
         }))
       : // otherwise we want "all" events (aka not pass any topics at all)
         [{ ...restParams, address: getAddress(contract.address) }];
@@ -203,12 +192,12 @@ export async function getContractEvents<
         logsParams.map((p) =>
           getLogsFromInsight({
             params: p,
-            chain: contract.chain,
-            client: contract.client,
+            contract,
           }),
         ),
       );
-    } catch {
+    } catch (e) {
+      console.warn("Error fetching from insight", e);
       // fetch from rpc
       logs = await Promise.all(
         logsParams.map((ethLogParams) => eth_getLogs(rpcRequest, ethLogParams)),
@@ -232,95 +221,55 @@ export async function getContractEvents<
 
 async function getLogsFromInsight(options: {
   params: GetLogsParamsExtra;
-  chain: Chain;
-  client: ThirdwebClient;
-  signature?: string;
+  contract: ThirdwebContract<Abi>;
 }): Promise<Log[]> {
-  const { params, chain, client, signature } = options;
+  const { params, contract } = options;
 
-  const chainServices = await getChainServices(chain);
+  const chainServices = await getChainServices(contract.chain);
   const insightEnabled = chainServices.some(
     (c) => c.service === "insight" && c.enabled,
   );
 
   if (!insightEnabled) {
-    throw new Error(`Insight is not available for chainId ${chain.id}`);
+    throw new Error(
+      `Insight is not available for chainId ${contract.chain.id}`,
+    );
   }
 
-  try {
-    let baseUrl = `https://${getThirdwebDomains().insight}/v1/events`;
-    if (params.address) {
-      baseUrl += `/${params.address}`;
-      if (signature) {
-        baseUrl += `/${signature}`;
-      }
-    }
-    const url = new URL(baseUrl);
-
-    url.searchParams.set("chain", chain.id.toString());
-    url.searchParams.set("limit", "500"); // this is max limit on insight
+  const fromBlock =
+    typeof params.fromBlock === "bigint" ? Number(params.fromBlock) : undefined;
 
-    if (params.blockHash) {
-      url.searchParams.set("filter_block_hash", params.blockHash);
-    } else {
-      if (params.fromBlock) {
-        const fromBlock =
-          typeof params.fromBlock === "bigint"
-            ? numberToHex(params.fromBlock)
-            : params.fromBlock;
-
-        url.searchParams.set("filter_block_number_gte", fromBlock);
-      }
-      if (params.toBlock) {
-        const toBlock =
-          typeof params.toBlock === "bigint"
-            ? numberToHex(params.toBlock)
-            : params.toBlock;
-
-        url.searchParams.set("filter_block_number_lte", toBlock);
-      }
-    }
+  const toBlock =
+    typeof params.toBlock === "bigint" ? Number(params.toBlock) : undefined;
 
-    if (params.topics) {
-      const args = params.topics.slice(1);
-      for (const [i, a] of args.entries()) {
-        if (a) {
-          url.searchParams.set(`filter_topic_${i + 1}`, a as Hex);
-        }
-      }
-    }
+  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 clientFetch = getClientFetch(client);
-    const result = await clientFetch(url.toString());
-    const fetchedEventData = (await result.json()) as {
-      data: {
-        chain_id: number;
-        block_number: number;
-        block_hash: string;
-        block_timestamp: string;
-        transaction_hash: string;
-        transaction_index: number;
-        log_index: number;
-        address: string;
-        data: string;
-        topics: string[];
-      }[];
-    };
-    const cleanedEventData = fetchedEventData.data.map((tx) => ({
-      chainId: tx.chain_id,
-      blockNumber: numberToHex(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,
-    }));
+  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));
-  } catch {
-    throw new Error("Error fetching events from insight");
-  }
+  return cleanedEventData.map((e) => formatLog(e));
 }

packages/thirdweb/src/insight/get-events.ts

@@ -0,0 +1,78 @@
+import {
+  type GetV1EventsByContractAddressData,
+  type GetV1EventsByContractAddressResponse,
+  getV1EventsByContractAddress,
+} from "@thirdweb-dev/insight";
+import type { AbiEvent } from "ox/AbiEvent";
+import { stringify } from "viem";
+import type { Chain } from "../chains/types.js";
+import type { ThirdwebClient } from "../client/client.js";
+import type { PreparedEvent } from "../event/prepare-event.js";
+import { getThirdwebDomains } from "../utils/domains.js";
+import { getClientFetch } from "../utils/fetch.js";
+
+export type ContractEvent = NonNullable<
+  GetV1EventsByContractAddressResponse["data"]
+>[number];
+
+/**
+ * Get contract events
+ * @example
+ * ```ts
+ * import { Insight } from "thirdweb";
+ *
+ * const events = await Insight.getContractEvents({
+ *   client,
+ *   chains: [sepolia],
+ *   contractAddress: "0x1234567890123456789012345678901234567890",
+ *   event: transferEvent(),
+ *   decodeLogs: true,
+ * });
+ * ```
+ * @insight
+ */
+export async function getContractEvents(options: {
+  client: ThirdwebClient;
+  chains: Chain[];
+  contractAddress: string;
+  event?: PreparedEvent<AbiEvent>;
+  decodeLogs?: boolean;
+  queryOptions?: GetV1EventsByContractAddressData["query"];
+}): Promise<ContractEvent[]> {
+  const { client, chains, contractAddress, event, queryOptions, decodeLogs } =
+    options;
+
+  const defaultQueryOptions: GetV1EventsByContractAddressData["query"] = {
+    chain: chains.map((chain) => chain.id),
+    limit: 100,
+    decode: decodeLogs,
+  };
+
+  if (event) {
+    defaultQueryOptions.filter_topic_0 = event.topics[0];
+    defaultQueryOptions.filter_topic_1 = event.topics[1];
+    defaultQueryOptions.filter_topic_2 = event.topics[2];
+    defaultQueryOptions.filter_topic_3 = event.topics[3];
+  }
+
+  const result = await getV1EventsByContractAddress({
+    baseUrl: `https://${getThirdwebDomains().insight}`,
+    fetch: getClientFetch(client),
+    path: {
+      contractAddress,
+    },
+    query: {
+      chain: chains.map((chain) => chain.id),
+      ...defaultQueryOptions,
+      ...queryOptions,
+    },
+  });
+
+  if (result.error) {
+    throw new Error(
+      `${result.response.status} ${result.response.statusText} - ${result.error ? stringify(result.error) : "Unknown error"}`,
+    );
+  }
+
+  return result.data?.data ?? [];
+}