envio 3.3.0-alpha.2 → 3.3.0-alpha.4

package/index.d.ts

@@ -997,24 +997,6 @@ export type SvmTokenBalance = {
   readonly postAmount?: string;
 };
 
-/** Parent transaction surfaced when an instruction's
- * `include_transaction` flag is `true`. */
-export type SvmTransaction = {
-  readonly signatures: readonly string[];
-  readonly feePayer?: string;
-  readonly success?: boolean;
-  readonly err?: string;
-  /** Lamports. */
-  readonly fee?: bigint;
-  readonly computeUnitsConsumed?: bigint;
-  readonly accountKeys: readonly string[];
-  readonly recentBlockhash?: string;
-  readonly version?: string;
-  /** SPL Token / Token-2022 balance snapshots for this transaction.
-   * Present when `include_token_balances` is `true`. */
-  readonly tokenBalances?: readonly SvmTokenBalance[];
-};
-
 export type SvmLog = {
   readonly kind: string;
   readonly message: string;
@@ -1033,6 +1015,7 @@ export type SvmLog = {
  * are base58 strings. */
 export type SvmInstruction<
   Params extends SvmInstructionParams = SvmInstructionParams,
+  Tx = SvmTransaction,
 > = {
   /** Program name as declared under `programs[].name` in `config.yaml`. */
   readonly programName: string;
@@ -1050,8 +1033,11 @@ export type SvmInstruction<
   readonly d8?: string;
   /** Borsh-decoded params. Present when a schema is configured and matched. */
   readonly params?: Params;
-  /** Present when the instruction's `include_transaction` is `true`. */
-  readonly transaction?: SvmTransaction;
+  /** Parent transaction. Carries only the fields selected via this
+   * instruction's `field_selection`; unselected fields are typed as
+   * `FieldNotSelected<...>` so reading them is a compile error. Always present
+   * (`{}` when no fields are selected). */
+  readonly transaction: Tx;
   /** Present when the instruction's `include_logs` is `true`; only logs
    * scoped to this exact instruction (matching `instruction_address`). */
   readonly logs?: readonly SvmLog[];
@@ -1327,7 +1313,10 @@ type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                   handler: (
                     args: SvmOnInstructionHandlerArgs<
                       Config,
-                      SvmInstruction<SvmParamsFromProgramTable<Programs[P][I]>>
+                      SvmInstruction<
+                        SvmParamsFromProgramTable<Programs[P][I]>,
+                        Programs[P][I]["transaction"]
+                      >
                     >,
                   ) => Promise<void>,
                 ) => void;
@@ -1695,6 +1684,7 @@ type EvmContractsT  = GlobalConfig extends { evm:  { contracts: infer X extends
 type FuelChainsT    = GlobalConfig extends { fuel: { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
 type FuelContractsT = GlobalConfig extends { fuel: { contracts: infer X extends Record<string, Record<string, any>> } } ? X : {};
 type SvmChainsT     = GlobalConfig extends { svm:  { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
+type SvmProgramsT   = GlobalConfig extends { svm:  { programs:  infer X extends Record<string, Record<string, any>> } } ? X : {};
 type EntitiesT      = GlobalConfig extends { entities: infer X extends Record<string, object> } ? X : {};
 type EnumsT         = GlobalConfig extends { enums: infer X extends Record<string, any> } ? X : {};
 
@@ -1716,6 +1706,18 @@ export type FuelChainId = IsEmptyObject<FuelChainsT> extends true ? NotConfigure
 /** Union of all configured SVM chain IDs. */
 export type SvmChainId  = IsEmptyObject<SvmChainsT>  extends true ? NotConfigured<"SvmChainId",  "Configure SVM chains">  : SvmChainsT [keyof SvmChainsT ]["id"];
 
+/** The SVM parent-transaction type generated from this project's
+ *  `field_selection`: the union of every instruction's `transaction` shape,
+ *  with unselected fields typed as `FieldNotSelected<...>`. Resolves to a
+ *  `NotConfigured` hint until `envio codegen` augments {@link Global}. */
+export type SvmTransaction = IsEmptyObject<SvmProgramsT> extends true
+  ? NotConfigured<"SvmTransaction", "Configure SVM programs">
+  : {
+      [P in keyof SvmProgramsT]: {
+        [I in keyof SvmProgramsT[P]]: SvmProgramsT[P][I]["transaction"];
+      }[keyof SvmProgramsT[P]];
+    }[keyof SvmProgramsT];
+
 /** Lookup an EVM event type by contract and event name. Without generics,
  *  resolves to the discriminated union of every EVM event in the project. */
 export type EvmEvent<

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.2",
+  "version": "3.3.0-alpha.4",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.2",
-    "envio-linux-x64-musl": "3.3.0-alpha.2",
-    "envio-linux-arm64": "3.3.0-alpha.2",
-    "envio-darwin-x64": "3.3.0-alpha.2",
-    "envio-darwin-arm64": "3.3.0-alpha.2"
+    "envio-linux-x64": "3.3.0-alpha.4",
+    "envio-linux-x64-musl": "3.3.0-alpha.4",
+    "envio-linux-arm64": "3.3.0-alpha.4",
+    "envio-darwin-x64": "3.3.0-alpha.4",
+    "envio-darwin-arm64": "3.3.0-alpha.4"
   }
 }

package/src/Bin.res

@@ -71,6 +71,9 @@ let run = async args => {
       }
     }
   } catch {
+  | Main.FatalError(_) =>
+    // Already logged with full context by Main.start's onError; just exit.
+    NodeJs.process->NodeJs.exitWithCode(Failure)
   | exn =>
     // Log just the exception's own message — wrapping it in "Failed at
     // initialization" and pino's err serializer buries the real cause under

package/src/Bin.res.mjs

@@ -79,6 +79,10 @@ async function run(args) {
     }
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID === Main.FatalError) {
+      Process.exit(1);
+      return;
+    }
     let e = Primitive_exceptions.internalToException(exn);
     let message = e.RE_EXN_ID === "JsExn" ? Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "Failed at initialization") : "Failed at initialization";
     Logging.error(message);

package/src/ChainFetching.res

@@ -11,13 +11,12 @@ type partitionQueryResponse = {
 let runContractRegistersOrThrow = async (
   ~itemsWithContractRegister: array<Internal.item>,
   ~config: Config.t,
-  ~chainState: ChainState.t,
   ~page: option<TransactionStore.t>,
 ) => {
   // contractRegister handlers can read event.transaction, so materialise the
   // selected fields onto the payloads before running them. All items belong to
   // the chain being fetched, hence its single page store and mask.
-  await chainState->ChainState.materializePageItems(~items=itemsWithContractRegister, ~page)
+  await ChainState.materializePageItems(~items=itemsWithContractRegister, ~page)
 
   let itemsWithDcs = []
 
@@ -233,7 +232,6 @@ let rec onQueryResponse = async (
         switch await runContractRegistersOrThrow(
           ~itemsWithContractRegister,
           ~config=state->IndexerState.config,
-          ~chainState,
           ~page=transactionStore,
         ) {
         | exception exn => IndexerState.errorExit(state, exn->ErrorHandling.make)
@@ -336,6 +334,15 @@ let fetchChain = async (
     // there's nothing to fetch. During backfill any such chain is idle.
     let reducedPolling = !isRealtime
 
+    // Accumulated across all queries dispatched in this tick so their per-query
+    // results collapse into a single completion log instead of one per query.
+    let dispatchedCount = switch action {
+    | FetchState.Ready(queries) => queries->Array.length
+    | WaitingForNewBlock | NothingToQuery => 0
+    }
+    let fetchedByPartition = Dict.make()
+    let fetchedCount = ref(0)
+
     // Owns its error boundary: launch doesn't catch, so any failure here (the
     // query, response handling, or dispatch itself) must stop the indexer.
     try {
@@ -361,6 +368,22 @@ let fetchChain = async (
               ~knownHeight=chainState->ChainState.knownHeight,
               ~isRealtime,
             )
+            fetchedCount := fetchedCount.contents + 1
+            fetchedByPartition->Dict.set(
+              query.partitionId,
+              {
+                "fromBlock": response.fromBlockQueried,
+                "toBlock": response.latestFetchedBlockNumber,
+                "numEvents": response.parsedQueueItems->Array.length,
+              },
+            )
+            if dispatchedCount > 0 && fetchedCount.contents === dispatchedCount {
+              Logging.trace({
+                "msg": "Finished querying",
+                "chainId": chain->ChainMap.Chain.toChainId,
+                "partitions": fetchedByPartition,
+              })
+            }
             await onQueryResponse(
               state,
               {chain, response, query},

package/src/ChainFetching.res.mjs

@@ -16,8 +16,8 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ContractRegisterContext from "./ContractRegisterContext.res.mjs";
 
-async function runContractRegistersOrThrow(itemsWithContractRegister, config, chainState, page) {
-  await ChainState.materializePageItems(chainState, itemsWithContractRegister, page);
+async function runContractRegistersOrThrow(itemsWithContractRegister, config, page) {
+  await ChainState.materializePageItems(itemsWithContractRegister, page);
   let itemsWithDcs = [];
   let onRegister = (item, contractAddress, contractName) => {
     let dc_registrationBlock = item.blockNumber;
@@ -145,7 +145,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let newItemsWithDcs;
   try {
-    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), chainState, transactionStore);
+    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), transactionStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));
@@ -176,10 +176,29 @@ async function fetchChain(state, chain, action, stateId, scheduleFetch, schedule
   let isRealtime = IndexerState.isRealtime(state);
   let sourceManager = ChainState.sourceManager(chainState);
   let reducedPolling = !isRealtime;
+  let dispatchedCount;
+  dispatchedCount = typeof action !== "object" ? 0 : action._0.length;
+  let fetchedByPartition = {};
+  let fetchedCount = {
+    contents: 0
+  };
   try {
     return await ChainState.dispatch(chainState, async query => {
       try {
         let response = await SourceManager.executeQuery(sourceManager, query, ChainState.knownHeight(chainState), isRealtime);
+        fetchedCount.contents = fetchedCount.contents + 1 | 0;
+        fetchedByPartition[query.partitionId] = {
+          fromBlock: response.fromBlockQueried,
+          toBlock: response.latestFetchedBlockNumber,
+          numEvents: response.parsedQueueItems.length
+        };
+        if (dispatchedCount > 0 && fetchedCount.contents === dispatchedCount) {
+          Logging.trace({
+            msg: "Finished querying",
+            chainId: chain,
+            partitions: fetchedByPartition
+          });
+        }
         return await onQueryResponse(state, {
           chain: chain,
           response: response,

package/src/ChainState.res

@@ -21,8 +21,6 @@ type t = {
   // transactionIndex). Fetch responses merge their page in; entries are pruned
   // as the chain progresses and dropped above the target on rollback.
   transactionStore: TransactionStore.t,
-  // Bitmask of the transaction fields the store materialises at batch prep.
-  transactionFieldMask: float,
 }
 
 // Per-chain shape returned by the status API.
@@ -67,7 +65,6 @@ let make = (
   ~numEventsProcessed=0.,
   ~timestampCaughtUpToHeadOrEndblock=None,
   ~isProgressAtHead=false,
-  ~transactionFieldMask=0.,
   ~logger: Pino.t,
 ): t => {
   logger,
@@ -82,7 +79,6 @@ let make = (
   reorgDetection,
   safeCheckpointTracking,
   transactionStore: TransactionStore.make(),
-  transactionFieldMask,
 }
 
 let makeInternal = (
@@ -328,7 +324,6 @@ let makeInternal = (
     ~committedProgressBlockNumber=progressBlockNumber,
     ~timestampCaughtUpToHeadOrEndblock,
     ~numEventsProcessed,
-    ~transactionFieldMask=config.ecosystem.transactionFieldMask(eventConfigs),
     ~logger,
   )
 }
@@ -503,18 +498,14 @@ let isAtHeadWithoutEndBlock = (cs: t) =>
 // Materialise the chain store's selected transaction fields onto a batch's
 // items at batch prep (the persistent-store path).
 let materializeBatchItems = (cs: t, ~items: array<Internal.item>) =>
-  cs.transactionStore->TransactionStore.materializeItems(~items, ~mask=cs.transactionFieldMask)
+  cs.transactionStore->TransactionStore.materializeItems(~items)
 
 // Materialise a fetch-response page's transactions onto its items before
 // contract-register handlers read them. `None` pages (RPC/Fuel/Simulate keep the
 // transaction inline) are a no-op.
-let materializePageItems = (
-  cs: t,
-  ~items: array<Internal.item>,
-  ~page: option<TransactionStore.t>,
-) =>
+let materializePageItems = (~items: array<Internal.item>, ~page: option<TransactionStore.t>) =>
   switch page {
-  | Some(store) => store->TransactionStore.materializeItems(~items, ~mask=cs.transactionFieldMask)
+  | Some(store) => store->TransactionStore.materializeItems(~items)
   | None => Promise.resolve()
   }
 

package/src/ChainState.res.mjs

@@ -38,12 +38,11 @@ function configAddresses(chainConfig) {
   return addresses;
 }
 
-function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionFieldMaskOpt, logger) {
+function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, logger) {
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
   let timestampCaughtUpToHeadOrEndblock = timestampCaughtUpToHeadOrEndblockOpt !== undefined ? Primitive_option.valFromOption(timestampCaughtUpToHeadOrEndblockOpt) : undefined;
   let isProgressAtHead = isProgressAtHeadOpt !== undefined ? isProgressAtHeadOpt : false;
-  let transactionFieldMask = transactionFieldMaskOpt !== undefined ? transactionFieldMaskOpt : 0;
   return {
     logger: logger,
     fetchState: fetchState,
@@ -56,8 +55,7 @@ function make(chainConfig, fetchState, sourceManager, reorgDetection, committedP
     pendingBudget: 0,
     reorgDetection: reorgDetection,
     safeCheckpointTracking: safeCheckpointTracking,
-    transactionStore: TransactionStore.make(),
-    transactionFieldMask: transactionFieldMask
+    transactionStore: TransactionStore.make()
   };
 }
 
@@ -176,7 +174,7 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       sources$1 = sources._0;
       break;
   }
-  return make(chainConfig, fetchState, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, config.ecosystem.transactionFieldMask(eventConfigs), logger);
+  return make(chainConfig, fetchState, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, logger);
 }
 
 function makeFromConfig(chainConfig, config, registrations, knownHeight) {
@@ -326,12 +324,12 @@ function isAtHeadWithoutEndBlock(cs) {
 }
 
 function materializeBatchItems(cs, items) {
-  return TransactionStore.materializeItems(cs.transactionStore, items, cs.transactionFieldMask);
+  return TransactionStore.materializeItems(cs.transactionStore, items);
 }
 
-function materializePageItems(cs, items, page) {
+function materializePageItems(items, page) {
   if (page !== undefined) {
-    return TransactionStore.materializeItems(Primitive_option.valFromOption(page), items, cs.transactionFieldMask);
+    return TransactionStore.materializeItems(Primitive_option.valFromOption(page), items);
   } else {
     return Promise.resolve();
   }

package/src/ChainState.resi

@@ -15,7 +15,6 @@ let make: (
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
-  ~transactionFieldMask: float=?,
   ~logger: Pino.t,
 ) => t
 
@@ -112,7 +111,6 @@ let handleQueryResult: (
 ) => unit
 let materializeBatchItems: (t, ~items: array<Internal.item>) => promise<unit>
 let materializePageItems: (
-  t,
   ~items: array<Internal.item>,
   ~page: option<TransactionStore.t>,
 ) => promise<unit>

package/src/CrossChainState.res

@@ -254,6 +254,21 @@ let checkAndFetch = async (
     idx := idx.contents + 1
   }
   admittedByChain->Dict.forEachWithKey((queries, chainId) => {
+    let partitions = Dict.make()
+    queries->Array.forEach((query: FetchState.query) =>
+      partitions->Dict.set(
+        query.partitionId,
+        {
+          "fromBlock": query.fromBlock,
+          "targetBlock": query.toBlock,
+        },
+      )
+    )
+    Logging.trace({
+      "msg": "Started querying",
+      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "partitions": partitions,
+    })
     actionByChain->Dict.set(chainId, FetchState.Ready(queries))
     // Mark the admitted queries in flight and reserve their size against the
     // shared budget; released as each response lands in handleQueryResult.

package/src/CrossChainState.res.mjs

@@ -170,6 +170,18 @@ async function checkAndFetch(crossChainState, dispatchChain) {
     idx = idx + 1 | 0;
   };
   Stdlib_Dict.forEachWithKey(admittedByChain, (queries, chainId) => {
+    let partitions = {};
+    queries.forEach(query => {
+      partitions[query.partitionId] = {
+        fromBlock: query.fromBlock,
+        targetBlock: query.toBlock
+      };
+    });
+    Logging.trace({
+      msg: "Started querying",
+      chainId: Stdlib_Int.fromString(chainId, undefined),
+      partitions: partitions
+    });
     actionByChain[chainId] = {
       TAG: "Ready",
       _0: queries

package/src/Ecosystem.res

@@ -2,8 +2,6 @@ type name = | @as("evm") Evm | @as("fuel") Fuel | @as("svm") Svm
 
 type t = {
   name: name,
-  blockFields: array<string>,
-  transactionFields: array<string>,
   blockNumberName: string,
   blockTimestampName: string,
   blockHashName: string,
@@ -36,10 +34,6 @@ type t = {
       registration from an item's opaque payload. `event.transaction` is written
       onto the payload at batch prep (HyperSync) or inline (RPC/simulate). */
   toEvent: Internal.eventItem => Internal.event,
-  /** Bitmask (as a float) of the transaction fields selected across the chain's
-      events — the set the store materialises at batch prep. `0.` when the
-      ecosystem carries transactions inline. */
-  transactionFieldMask: array<Internal.eventConfig> => float,
   /** Build the per-item child logger for an event item, with
       ecosystem-specific log fields (EVM/Fuel: contract/event/address; SVM:
       program/instruction/programId). Closes over the injected logger. */

package/src/EventConfigBuilder.res

@@ -326,28 +326,50 @@ let compileAddressFilter: string => (
   return new Function("event", "blockNumber", "indexingAddresses", body);
 }`)
 
-// Body of the client-side address filter for a DNF of address-filtered param
-// names (OR of AND-groups): keep the event only if some group's params are all
-// registered at or before the log's block. The DNF is fixed here, so it's
-// unrolled into one boolean expression — no per-event closure, loop, or array.
-// `None` when there's no address-param filter. Exposed for snapshotting.
-let buildAddressFilterBody = (groups: array<array<string>>): option<string> => {
-  switch groups {
+// Body of the client-side address filter. Two analogous registered-at-or-before
+// checks, ANDed: (1) for non-wildcard events, the log's srcAddress must itself be
+// registered (ownership is resolved structurally by partition, but the temporal
+// `effectiveStartBlock` gate lives here now); (2) a DNF of address-filtered param
+// names (OR of AND-groups) for events that filter an indexed address param. The
+// DNF is fixed here, so it's unrolled into one boolean expression — no per-event
+// closure, loop, or array. `None` only for wildcard events without a param
+// filter. Exposed for snapshotting.
+// `srcAddressExpr` is the JS expression for the event's owning address: EVM and
+// Fuel events expose `event.srcAddress`; SVM instructions expose `event.programId`.
+let buildAddressFilterBody = (
+  groups: array<array<string>>,
+  ~isWildcard: bool,
+  ~srcAddressExpr: string="event.srcAddress",
+): option<string> => {
+  let paramLeaf = name =>
+    `(ic = indexingAddresses[p[${JSON.stringify(
+        JSON.String(name),
+      )}]]) !== undefined && ic.effectiveStartBlock <= blockNumber`
+  let paramDnf = switch groups {
   | [] => None
   | _ =>
-    let leaf = name =>
-      `(ic = indexingAddresses[p[${JSON.stringify(
-          JSON.String(name),
-        )}]]) !== undefined && ic.effectiveStartBlock <= blockNumber`
-    let groupExprs =
-      groups->Array.map(group => "(" ++ group->Array.map(leaf)->Array.join(" && ") ++ ")")
-    Some("var p = event.params, ic; return " ++ groupExprs->Array.join(" || ") ++ ";")
+    Some(
+      groups
+      ->Array.map(group => "(" ++ group->Array.map(paramLeaf)->Array.join(" && ") ++ ")")
+      ->Array.join(" || "),
+    )
+  }
+  let srcLeaf = `(ic = indexingAddresses[${srcAddressExpr}]) !== undefined && ic.effectiveStartBlock <= blockNumber`
+  switch (isWildcard, paramDnf) {
+  | (true, None) => None
+  | (true, Some(dnf)) => Some("var p = event.params, ic; return " ++ dnf ++ ";")
+  | (false, None) => Some("var ic; return " ++ srcLeaf ++ ";")
+  | (false, Some(dnf)) =>
+    Some("var p = event.params, ic; return " ++ srcLeaf ++ " && (" ++ dnf ++ ");")
   }
 }
 
-let buildAddressFilter = (groups: array<array<string>>): option<
-  (Internal.eventPayload, int, dict<Internal.indexingContract>) => bool,
-> => buildAddressFilterBody(groups)->Option.map(compileAddressFilter)
+let buildAddressFilter = (
+  groups: array<array<string>>,
+  ~isWildcard: bool,
+  ~srcAddressExpr: string="event.srcAddress",
+): option<(Internal.eventPayload, int, dict<Internal.indexingContract>) => bool> =>
+  buildAddressFilterBody(groups, ~isWildcard, ~srcAddressExpr)->Option.map(compileAddressFilter)
 
 // ============== Build complete EVM event config ==============
 
@@ -415,11 +437,12 @@ let buildEvmEventConfig = (
     simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
-    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups),
+    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
     dependsOnAddresses: !isWildcard || filterByAddresses,
     startBlock: resolvedStartBlock,
     selectedBlockFields,
     selectedTransactionFields,
+    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
     sighash,
     topicCount,
     paramsMetadata: params,
@@ -471,12 +494,14 @@ let buildSvmInstructionEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
     startBlock,
     programId,
     discriminator,
     discriminatorByteLen,
     includeLogs,
     selectedTransactionFields,
+    transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
     accountFilters,
     isInner,
     accounts,
@@ -541,9 +566,11 @@ let buildFuelEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
     startBlock,
     // Fuel keeps the transaction inline on the payload; nothing to materialise.
     selectedTransactionFields: Utils.Set.make(),
+    transactionFieldMask: 0.,
     kind: fuelKind,
   }
 }

package/src/EventConfigBuilder.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Evm from "./sources/Evm.res.mjs";
+import * as Svm from "./sources/Svm.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as FuelSDK from "./sources/FuelSDK.res.mjs";
@@ -255,17 +257,27 @@ let compileAddressFilter = (function (body) {
   return new Function("event", "blockNumber", "indexingAddresses", body);
 });
 
-function buildAddressFilterBody(groups) {
-  if (groups.length === 0) {
-    return;
+function buildAddressFilterBody(groups, isWildcard, srcAddressExprOpt) {
+  let srcAddressExpr = srcAddressExprOpt !== undefined ? srcAddressExprOpt : "event.srcAddress";
+  let paramLeaf = name => `(ic = indexingAddresses[p[` + JSON.stringify(name) + `]]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
+  let paramDnf = groups.length !== 0 ? groups.map(group => "(" + group.map(paramLeaf).join(" && ") + ")").join(" || ") : undefined;
+  let srcLeaf = `(ic = indexingAddresses[` + srcAddressExpr + `]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
+  if (isWildcard) {
+    if (paramDnf !== undefined) {
+      return "var p = event.params, ic; return " + paramDnf + ";";
+    } else {
+      return;
+    }
+  } else if (paramDnf !== undefined) {
+    return "var p = event.params, ic; return " + srcLeaf + " && (" + paramDnf + ");";
+  } else {
+    return "var ic; return " + srcLeaf + ";";
   }
-  let leaf = name => `(ic = indexingAddresses[p[` + JSON.stringify(name) + `]]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
-  let groupExprs = groups.map(group => "(" + group.map(leaf).join(" && ") + ")");
-  return "var p = event.params, ic; return " + groupExprs.join(" || ") + ";";
 }
 
-function buildAddressFilter(groups) {
-  return Stdlib_Option.map(buildAddressFilterBody(groups), compileAddressFilter);
+function buildAddressFilter(groups, isWildcard, srcAddressExprOpt) {
+  let srcAddressExpr = srcAddressExprOpt !== undefined ? srcAddressExprOpt : "event.srcAddress";
+  return Stdlib_Option.map(buildAddressFilterBody(groups, isWildcard, srcAddressExpr), compileAddressFilter);
 }
 
 function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, blockFields, transactionFields, startBlock, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
@@ -284,6 +296,7 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   let filterByAddresses = match.filterByAddresses;
   let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
   let match$1 = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
+  let selectedTransactionFields = match$1[1];
   return {
     id: sighash + "_" + topicCount.toString(),
     name: eventName,
@@ -291,13 +304,14 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
     isWildcard: isWildcard,
     filterByAddresses: filterByAddresses,
     dependsOnAddresses: !isWildcard || filterByAddresses,
-    clientAddressFilter: Stdlib_Option.map(buildAddressFilterBody(match.addressFilterParamGroups), compileAddressFilter),
+    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
     startBlock: resolvedStartBlock,
-    selectedTransactionFields: match$1[1],
+    selectedTransactionFields: selectedTransactionFields,
+    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
     getEventFiltersOrThrow: match.getEventFiltersOrThrow,
     selectedBlockFields: match$1[0],
     sighash: sighash,
@@ -320,12 +334,14 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
     selectedTransactionFields: selectedTransactionFields,
+    transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
@@ -388,12 +404,14 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
     selectedTransactionFields: new Set(),
+    transactionFieldMask: 0,
     kind: fuelKind
   };
 }