thirdweb 5.94.2 → 5.95.0-nightly-64bd603301b3067b6a69a29f66a28dee7ffa38f5-20250416000349

package/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

package/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,6 +36,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
     const events = await getContractEvents({
       contract: USDT_CONTRACT,
       blockRange: 10n,
+      useIndexer: false,
     });
     expect(events.length).toBe(241);
 
@@ -42,6 +44,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
       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,6 +54,7 @@ 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);
 
@@ -58,6 +62,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
       contract: USDT_CONTRACT,
       toBlock: FORK_BLOCK_NUMBER - 30n,
       blockRange: 20n,
+      useIndexer: false,
     });
     expect(eventsToBlock.length).toBe(eventsFromBlock.length);
 
@@ -65,6 +70,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("getEvents", () => {
       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");
+  });
 });

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

@@ -1,18 +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 { getChainServices } from "../../chains/utils.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,
@@ -21,6 +17,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 +31,7 @@ export type GetContractEventsOptionsDirect<
   contract: ThirdwebContract<abi>;
   events?: abiEvents;
   strict?: TStrict;
+  useIndexer?: boolean;
 };
 
 export type GetContractEventsOptions<
@@ -49,6 +47,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 +108,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 +172,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 +183,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", 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 +218,58 @@ export async function getContractEvents<
     events: resolvedEvents,
   });
 }
+
+async function getLogsFromInsight(options: {
+  params: GetLogsParamsExtra;
+  contract: ThirdwebContract<Abi>;
+}): Promise<Log[]> {
+  const { params, contract } = options;
+
+  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 ${contract.chain.id}`,
+    );
+  }
+
+  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/exports/insight.ts

@@ -0,0 +1 @@
+export * from "../insight/index.js";

package/src/exports/thirdweb.ts

@@ -76,6 +76,11 @@ export {
  */
 export * as Bridge from "../bridge/index.js";
 
+/**
+ * INSIGHT
+ */
+export * as Insight from "../insight/index.js";
+
 /**
  * WALLETS
  */

package/src/extensions/dynamic-contracts/__generated__/IExtensionManager/read/getAllExtensions.ts

@@ -0,0 +1,104 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0x4a00cc48" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    type: "tuple[]",
+    components: [
+      {
+        type: "tuple",
+        name: "metadata",
+        components: [
+          {
+            type: "string",
+            name: "name",
+          },
+          {
+            type: "string",
+            name: "metadataURI",
+          },
+          {
+            type: "address",
+            name: "implementation",
+          },
+        ],
+      },
+      {
+        type: "tuple[]",
+        name: "functions",
+        components: [
+          {
+            type: "bytes4",
+            name: "functionSelector",
+          },
+          {
+            type: "string",
+            name: "functionSignature",
+          },
+        ],
+      },
+    ],
+  },
+] as const;
+
+/**
+ * Checks if the `getAllExtensions` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `getAllExtensions` method is supported.
+ * @extension DYNAMIC-CONTRACTS
+ * @example
+ * ```ts
+ * import { isGetAllExtensionsSupported } from "thirdweb/extensions/dynamic-contracts";
+ * const supported = isGetAllExtensionsSupported(["0x..."]);
+ * ```
+ */
+export function isGetAllExtensionsSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the getAllExtensions function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension DYNAMIC-CONTRACTS
+ * @example
+ * ```ts
+ * import { decodeGetAllExtensionsResult } from "thirdweb/extensions/dynamic-contracts";
+ * const result = decodeGetAllExtensionsResultResult("...");
+ * ```
+ */
+export function decodeGetAllExtensionsResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getAllExtensions" function on the contract.
+ * @param options - The options for the getAllExtensions function.
+ * @returns The parsed result of the function call.
+ * @extension DYNAMIC-CONTRACTS
+ * @example
+ * ```ts
+ * import { getAllExtensions } from "thirdweb/extensions/dynamic-contracts";
+ *
+ * const result = await getAllExtensions({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function getAllExtensions(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/thirdweb/write/publish.ts

@@ -5,6 +5,7 @@ import type { ThirdwebClient } from "../../../client/client.js";
 import { ZERO_ADDRESS } from "../../../constants/addresses.js";
 import { getContract } from "../../../contract/contract.js";
 import { CONTRACT_PUBLISHER_ADDRESS } from "../../../contract/deployment/publisher.js";
+import { isGetAllExtensionsSupported } from "../../../extensions/dynamic-contracts/__generated__/IExtensionManager/read/getAllExtensions.js";
 import { download } from "../../../storage/download.js";
 import { upload } from "../../../storage/upload.js";
 import type { BaseTransactionOptions } from "../../../transaction/types.js";
@@ -79,8 +80,14 @@ export function publishContract(
         compositeAbi: options.metadata.compositeAbi,
         constructorParams: options.metadata.constructorParams,
         implConstructorParams: options.metadata.implConstructorParams,
-        defaultExtensions: options.metadata.defaultExtensions,
-        defaultModules: options.metadata.defaultModules,
+        defaultExtensions:
+          routerType === "dynamic"
+            ? options.metadata.defaultExtensions
+            : undefined,
+        defaultModules:
+          routerType === "modular"
+            ? options.metadata.defaultModules
+            : undefined,
         deployType: options.metadata.deployType,
         description: options.metadata.description,
         displayName: options.metadata.displayName,
@@ -131,6 +138,7 @@ function getRouterType(abi: Abi) {
     .filter((f) => f.type === "function")
     .map((f) => toFunctionSelector(f));
   const isModule = isGetInstalledModulesSupported(fnSelectors);
-  // TODO add dynamic detection
-  return isModule ? "modular" : "none";
+  const isDynamic = isGetAllExtensionsSupported(fnSelectors);
+
+  return isModule ? "modular" : isDynamic ? "dynamic" : "none";
 }

package/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 ?? [];
+}