envio 3.15.0 → 3.16.0-subgraph

package/src/Config.res

@@ -65,6 +65,7 @@ type chain = {
   endBlock?: int,
   maxReorgDepth: int,
   blockLag: int,
+  blockThrottle: int,
   contracts: array<contract>,
   sourceConfig: sourceConfig,
 }
@@ -154,6 +155,9 @@ type t = {
   // reach, so its checkpoints have to be comparable across chains.
   checkpointSequence: CheckpointSequence.t,
   envioInfo: JSON.t,
+  // Set only in subgraph mode: the translated manifest, which is what makes
+  // the subgraph runtime take over handler registration.
+  subgraph: option<JSON.t>,
 }
 
 type rpcSourceFor = | @as("sync") Sync | @as("fallback") Fallback | @as("realtime") Realtime
@@ -217,6 +221,7 @@ let publicConfigChainSchema = S.schema(s =>
     "endBlock": s.matches(S.option(S.int)),
     "maxReorgDepth": s.matches(S.option(S.int)),
     "blockLag": s.matches(S.option(S.int)),
+    "blockThrottle": s.matches(S.option(S.int)),
     // EVM/Fuel source config (hypersync for EVM, hyperfuel for Fuel)
     "hypersync": s.matches(S.option(S.string)),
     "rpcs": s.matches(S.option(S.array(rpcConfigSchema))),
@@ -616,6 +621,7 @@ let publicConfigSchema = S.schema(s =>
     "svm": s.matches(S.option(publicConfigEcosystemSchema)),
     "enums": s.matches(S.option(S.dict(S.array(S.string)))),
     "entities": s.matches(S.option(S.array(entityJsonSchema))),
+    "subgraph": s.matches(S.option(S.json(~validate=false))),
   }
 )
 
@@ -698,6 +704,10 @@ let toEnvioInfo = (publicConfigJson: JSON.t): JSON.t => {
   switch envioInfo {
   | Object(obj) => {
       commandFields->Array.forEach(field => obj->Utils.Dict.deleteInPlace(field))
+      // The subgraph blob is how the runtime finds mappings. None of it
+      // describes stored data — that's already in `evm` / `entities` — so a
+      // specVersion bump or a mapping-path edit must not force a reset.
+      obj->Utils.Dict.deleteInPlace("subgraph")
       ecosystemFields->Array.forEach(ecosystem =>
         switch obj->Dict.get(ecosystem) {
         | Some(Object(ecosystemDict)) => ecosystemDict->Utils.Dict.deleteInPlace("chains")
@@ -1069,18 +1079,23 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
-        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // One less than the 200 blocks behind the head a source checks for a
+        // lagging node, so the backfill, which stops one block below the window,
+        // ends exactly where those checks begin.
+        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         // Tower BFT roots a block once 32 votes lock it in (MAX_LOCKOUT_HISTORY
         // is 31, plus the slot itself), which is what `finalized` waits for — so
         // 32 is the protocol's own bound on how far a fork can be replaced. That
         // bound counts *blocks* while the threshold here is measured in slot
         // numbers, and skipped slots make the slot distance the larger of the
         // two, so the default keeps a wide margin over it. Slots are ~0.4s, so
-        // even this spans well under two minutes of chain.
-        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        // even this spans well under two minutes of chain. One less than 200
+        // for the same reason as EVM: the backfill stops one slot below it.
+        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(199)
         | Ecosystem.Fuel => 0
         },
         blockLag: publicChainConfig["blockLag"]->Option.getOr(0),
+        blockThrottle: publicChainConfig["blockThrottle"]->Option.getOr(0),
         contracts,
         sourceConfig,
       }
@@ -1145,6 +1160,18 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => []
   }
 
+  switch publicConfig["subgraph"] {
+  | Some(subgraph) =>
+    Env.subgraphMode := true
+    Env.subgraphHasTemplates :=
+      subgraph
+      ->JSON.Decode.object
+      ->Option.flatMap(manifest => manifest->Dict.get("templates"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.mapOr(false, templates => templates->Array.length > 0)
+  | None => ()
+  }
+
   let config = {
     name: publicConfig["name"],
     description: publicConfig["description"],
@@ -1173,6 +1200,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     allEnums,
     checkpointSequence: CheckpointSequence.fromEntities(userEntities),
     envioInfo: publicConfigJson->toEnvioInfo,
+    subgraph: publicConfig["subgraph"],
   }
 
   switch publicConfig["isolatedChains"] {

package/src/Config.res.mjs

@@ -88,6 +88,7 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
   endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   maxReorgDepth: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   blockLag: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
+  blockThrottle: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   hypersync: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   rpcs: s.m(S$RescriptSchema.option(S$RescriptSchema.array(rpcConfigSchema))),
   contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(chainContractSchema)))
@@ -448,7 +449,8 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   svm: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   enums: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(S$RescriptSchema.array(S$RescriptSchema.string)))),
-  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema)))
+  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema))),
+  subgraph: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
 }));
 
 function contractMappingOf(chainConfigs) {
@@ -518,6 +520,7 @@ function toEnvioInfo(publicConfigJson) {
   let envioInfo = JSON.parse(JSON.stringify(publicConfigJson));
   if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
     commandFields.forEach(field => Utils.Dict.deleteInPlace(envioInfo, field));
+    Utils.Dict.deleteInPlace(envioInfo, "subgraph");
     ecosystemFields.forEach(ecosystem => {
       let match = envioInfo[ecosystem];
       if (typeof match === "object" && match !== null && !Array.isArray(match)) {
@@ -762,7 +765,7 @@ function fromPublic(publicConfigJson) {
         break;
       case "evm" :
       case "svm" :
-        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 200);
+        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 199);
         break;
     }
     return {
@@ -773,6 +776,7 @@ function fromPublic(publicConfigJson) {
       endBlock: publicChainConfig.endBlock,
       maxReorgDepth: tmp,
       blockLag: Stdlib_Option.getOr(publicChainConfig.blockLag, 0),
+      blockThrottle: Stdlib_Option.getOr(publicChainConfig.blockThrottle, 0),
       contracts: contracts,
       sourceConfig: sourceConfig
     };
@@ -806,6 +810,11 @@ function fromPublic(publicConfigJson) {
       name: Utils.$$String.capitalize(param[0]),
       handler: param[1].handler
     })) : [];
+  let subgraph = publicConfig.subgraph;
+  if (subgraph !== undefined) {
+    Env.subgraphMode.contents = true;
+    Env.subgraphHasTemplates.contents = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(subgraph), manifest => manifest["templates"]), Stdlib_JSON.Decode.array), false, templates => templates.length !== 0);
+  }
   let config_name = publicConfig.name;
   let config_description = publicConfig.description;
   let config_handlers = Stdlib_Option.getOr(publicConfig.handlers, "src/handlers");
@@ -820,6 +829,7 @@ function fromPublic(publicConfigJson) {
   let config_projectFlags = Stdlib_Option.getOr(publicConfig.projectFlags, "");
   let config_checkpointSequence = CheckpointSequence.fromEntities(userEntities);
   let config_envioInfo = toEnvioInfo(publicConfigJson);
+  let config_subgraph = publicConfig.subgraph;
   let config = {
     name: config_name,
     description: config_description,
@@ -847,7 +857,8 @@ function fromPublic(publicConfigJson) {
     userEntities: userEntities,
     allEnums: allEnums,
     checkpointSequence: config_checkpointSequence,
-    envioInfo: config_envioInfo
+    envioInfo: config_envioInfo,
+    subgraph: config_subgraph
   };
   let chainIds = publicConfig.isolatedChains;
   if (chainIds !== undefined) {
@@ -972,7 +983,7 @@ function diffPaths(stored, current) {
         }
         return;
       }
-    } else {
+    } else if (s !== null) {
       switch (typeof s) {
         case "object" :
           if (typeof c === "object" && c !== null && !Array.isArray(c)) {

package/src/ContractRegisterContext.res

@@ -20,11 +20,7 @@ let make = (~config: Config.t): Internal.contractRegisterContext => {
     {
       enumerable: true,
       get: () =>
-        (
-          RunScope.currentContractRegisterRunOrThrow(
-            ~prop="chain",
-          ).item->Internal.castUnsafeEventItem
-        ).chainId,
+        RunScope.currentContractRegisterRunOrThrow(~prop="chain").item->Internal.getItemChainId,
     },
   )
   ->ignore
@@ -49,7 +45,8 @@ let make = (~config: Config.t): Internal.contractRegisterContext => {
               // The value is passed from user-land, so validate and checksum/lowercase it.
               address: config->Config.normalizeUserAddress(contractAddress),
               contractName,
-              registrationBlock: (run.item->Internal.castUnsafeEventItem).blockNumber,
+              registrationBlock: run.item->Internal.getItemBlockNumber,
+              creationRound: ?run.creationRound,
             })
             ->ignore
           },

package/src/ContractRegisterContext.res.mjs

@@ -4,6 +4,7 @@ import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as RunScope from "./RunScope.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -12,7 +13,7 @@ function make(config) {
   let chain = Object.create(Utils.StrictObject.makePrototype(prop => Stdlib_JsError.throwWithMessage(`Invalid contract name '` + prop + `' on context.chain. ` + EntityFilter.codegenHelpMessage)));
   Object.defineProperty(chain, "id", {
     enumerable: true,
-    get: () => RunScope.currentContractRegisterRunOrThrow("chain").item.chainId
+    get: () => Internal.getItemChainId(RunScope.currentContractRegisterRunOrThrow("chain").item)
   });
   let contractNames = new Set();
   ChainMap.values(config.chainMap).forEach(chainConfig => {
@@ -29,7 +30,8 @@ function make(config) {
           run.registrations.push({
             address: Config.normalizeUserAddress(config, contractAddress),
             contractName: contractName,
-            registrationBlock: run.item.blockNumber
+            registrationBlock: run.item.blockNumber,
+            creationRound: run.creationRound
           });
         }
       }

package/src/Core.res

@@ -18,6 +18,8 @@ type loggerCtor
 type mockHyperSyncServerCtor
 // Test-only: the ledger behind envio-tests' MockSource.
 type mockSourceCtor
+// Test-only: the virtual clock a scenario's source layer runs on.
+type virtualClockCtor
 type fromUserApiOptions = {
   schema?: string,
   env?: dict<string>,
@@ -31,48 +33,43 @@ type fromUserApiResult = {
   indexerCode: Null.t<string>,
 }
 
-// One column of a Postgres table, flattened for the boundary: napi carries no
-// tagged union, so the field type arrives as its name plus whichever of the
-// modifiers it takes.
-type pgColumnInput = {
-  // The database column name, renames already resolved.
-  name: string,
-  fieldType: string,
-  isArray: bool,
-  isNullable: bool,
-  isPrimaryKey: bool,
-  defaultValue?: string,
-  precision?: int,
-  scale?: int,
-  enumName?: string,
+type fromSubgraphOptions = {
+  name?: string,
+  env?: dict<string>,
+  files?: dict<string>,
+  root?: string,
 }
 
-type pgTableInput = {
-  // In the order the table declares them.
-  columns: array<pgColumnInput>,
-  // The columns a batch's rows carry, in the order they are laid out.
-  writeColumns: array<string>,
-  partitionByColumn?: string,
-  appendOnly: bool,
-  // An entity's history table, and the column its chain is in when it is
-  // per-chain.
-  historyTable?: string,
-  chainIdColumn?: string,
-}
+type bundledCodegenResult = {outputDir: string, files: array<string>}
 
-type pgIndexColumnInput = {
-  name: string,
-  direction: string,
-}
-
-type pgIndexInput = {
-  tableName: string,
-  columns: array<pgIndexColumnInput>,
-  method: string,
+type filledGeneratedFile = {
+  file: string,
+  source: string,
+  abiName?: string,
+  renamedFrom?: string,
+  undeclared: bool,
 }
 
 type addon = {
-  getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
+  getConfigJson: (
+    ~configPath: Null.t<string>,
+    ~directory: Null.t<string>,
+    ~portsServedHere: array<int>,
+  ) => string,
+  fromSubgraph: (string, string, fromSubgraphOptions) => fromUserApiResult,
+  subgraphFileToJavascript: (string, string, bool) => string,
+  subgraphRegisterHandlers: (array<string>, array<array<string>>) => array<array<string>>,
+  subgraphSureCreates: (string, array<string>, array<string>) => array<array<string>>,
+  subgraphKeccak256: Uint8Array.t => Uint8Array.t,
+  subgraphAbiDecode: (string, Uint8Array.t, bool) => unknown,
+  subgraphAbiEncodeCall: (string, string, JSON.t) => string,
+  subgraphBundledCodegen: (string, Null.t<string>) => bundledCodegenResult,
+  subgraphBundledCodegenCurrent: (string, string) => bool,
+  subgraphMissingGraphCliMessage: string => string,
+  subgraphFillGenerated: (string, string, string, array<string>) => array<filledGeneratedFile>,
+  subgraphWorkspacePackages: string => dict<string>,
+  subgraphWorkspaceRoot: string => Null.t<string>,
+  subgraphScriptsWriting: (string, string) => array<array<string>>,
   encodeIndexedTopic: (~abiType: string, ~value: unknown) => EvmTypes.Hex.t,
   isSvmPubkey: (~value: string) => bool,
   fromUserApi: (string, fromUserApiOptions) => fromUserApiResult,
@@ -107,6 +104,8 @@ type addon = {
   mockHyperSyncServer: mockHyperSyncServerCtor,
   @as("MockSource")
   mockSource: mockSourceCtor,
+  @as("VirtualClock")
+  virtualClock: virtualClockCtor,
   encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
   normalizeEvmAddress: (~address: string, ~shouldChecksum: bool) => Null.t<Address.t>,
   renderAddresses: (
@@ -330,11 +329,24 @@ let getAddon = () =>
     }
   }
 
+// The ports servers in this process listen on. Node has no public list of
+// them; `_getActiveHandles` has held them since its first releases, and
+// without it nothing is reported.
+let portsServedHere: unit => array<int> = %raw(`() =>
+  typeof process._getActiveHandles !== "function"
+    ? []
+    : process
+        ._getActiveHandles()
+        .map((handle) => (handle?.listening === true && typeof handle.address === "function" ? handle.address() : null))
+        .filter((address) => typeof address?.port === "number")
+        .map((address) => address.port)`)
+
 let getConfigJson = (~configPath=?, ~directory=?) => {
   let addon = getAddon()
   addon.getConfigJson(
     ~configPath=configPath->Null.fromOption,
     ~directory=directory->Null.fromOption,
+    ~portsServedHere=portsServedHere(),
   )
 }
 
@@ -356,6 +368,53 @@ let fromUserApi = (~schema=?, ~env=?, ~files=?, ~withIndexerTypes=false, yaml) =
   )
 }
 
+/// Parses a subgraph project without touching the filesystem: subgraph.yaml and
+/// its schema inline, ABI bodies through `files`.
+let fromSubgraph = (~name=?, ~env=?, ~files=?, ~root=?, ~manifest, ~schema) => {
+  let addon = getAddon()
+  addon.fromSubgraph(manifest, schema, {?name, ?env, ?files, ?root})
+}
+
+let subgraphFileToJavascript = (~source, ~path, ~legacyNulls) => {
+  let addon = getAddon()
+  addon.subgraphFileToJavascript(source, path, legacyNulls)
+}
+
+let subgraphRegisterHandlers = (~mappingFiles, ~handlers) => {
+  let addon = getAddon()
+  addon.subgraphRegisterHandlers(mappingFiles, handlers)
+}
+
+let subgraphSureCreates = (~mappingFile, ~handlers, ~templates) =>
+  getAddon().subgraphSureCreates(mappingFile, handlers, templates)
+
+let subgraphKeccak256 = bytes => getAddon().subgraphKeccak256(bytes)
+
+let subgraphAbiDecode = (ty, data, params) => getAddon().subgraphAbiDecode(ty, data, params)
+
+let subgraphAbiEncodeCall = (name, inputs, args) =>
+  getAddon().subgraphAbiEncodeCall(name, inputs, args)
+
+let subgraphBundledCodegen = (~manifestFile, ~outputDir: option<string>) => {
+  let addon = getAddon()
+  addon.subgraphBundledCodegen(manifestFile, outputDir->Null.fromOption)
+}
+
+let subgraphBundledCodegenCurrent = (~manifestFile, ~outputDir) =>
+  getAddon().subgraphBundledCodegenCurrent(manifestFile, outputDir)
+
+let subgraphMissingGraphCliMessage = generated =>
+  getAddon().subgraphMissingGraphCliMessage(generated)
+
+let subgraphFillGenerated = (~root, ~manifestFile, ~outputDir, ~wanted) =>
+  getAddon().subgraphFillGenerated(root, manifestFile, outputDir, wanted)
+
+let subgraphWorkspacePackages = root => getAddon().subgraphWorkspacePackages(root)
+
+let subgraphWorkspaceRoot = root => getAddon().subgraphWorkspaceRoot(root)
+
+let subgraphScriptsWriting = (~dir, ~needle) => getAddon().subgraphScriptsWriting(dir, needle)
+
 let runCli = args => {
   let addon = getAddon()
   addon.runCli(~args, ~envioPackageDir=Null.make(envioPackageDir))

package/src/Core.res.mjs

@@ -216,9 +216,18 @@ function getAddon() {
   return a$1;
 }
 
+let portsServedHere = (() =>
+  typeof process._getActiveHandles !== "function"
+    ? []
+    : process
+        ._getActiveHandles()
+        .map((handle) => (handle?.listening === true && typeof handle.address === "function" ? handle.address() : null))
+        .filter((address) => typeof address?.port === "number")
+        .map((address) => address.port));
+
 function getConfigJson(configPath, directory) {
   let addon = getAddon();
-  return addon.getConfigJson(Stdlib_Null.fromOption(configPath), Stdlib_Null.fromOption(directory));
+  return addon.getConfigJson(Stdlib_Null.fromOption(configPath), Stdlib_Null.fromOption(directory), portsServedHere());
 }
 
 function fromUserApi(schema, env, files, withIndexerTypesOpt, yaml) {
@@ -232,6 +241,71 @@ function fromUserApi(schema, env, files, withIndexerTypesOpt, yaml) {
   });
 }
 
+function fromSubgraph(name, env, files, root, manifest, schema) {
+  let addon = getAddon();
+  return addon.fromSubgraph(manifest, schema, {
+    name: name,
+    env: env,
+    files: files,
+    root: root
+  });
+}
+
+function subgraphFileToJavascript(source, path, legacyNulls) {
+  let addon = getAddon();
+  return addon.subgraphFileToJavascript(source, path, legacyNulls);
+}
+
+function subgraphRegisterHandlers(mappingFiles, handlers) {
+  let addon = getAddon();
+  return addon.subgraphRegisterHandlers(mappingFiles, handlers);
+}
+
+function subgraphSureCreates(mappingFile, handlers, templates) {
+  return getAddon().subgraphSureCreates(mappingFile, handlers, templates);
+}
+
+function subgraphKeccak256(bytes) {
+  return getAddon().subgraphKeccak256(bytes);
+}
+
+function subgraphAbiDecode(ty, data, params) {
+  return getAddon().subgraphAbiDecode(ty, data, params);
+}
+
+function subgraphAbiEncodeCall(name, inputs, args) {
+  return getAddon().subgraphAbiEncodeCall(name, inputs, args);
+}
+
+function subgraphBundledCodegen(manifestFile, outputDir) {
+  let addon = getAddon();
+  return addon.subgraphBundledCodegen(manifestFile, Stdlib_Null.fromOption(outputDir));
+}
+
+function subgraphBundledCodegenCurrent(manifestFile, outputDir) {
+  return getAddon().subgraphBundledCodegenCurrent(manifestFile, outputDir);
+}
+
+function subgraphMissingGraphCliMessage(generated) {
+  return getAddon().subgraphMissingGraphCliMessage(generated);
+}
+
+function subgraphFillGenerated(root, manifestFile, outputDir, wanted) {
+  return getAddon().subgraphFillGenerated(root, manifestFile, outputDir, wanted);
+}
+
+function subgraphWorkspacePackages(root) {
+  return getAddon().subgraphWorkspacePackages(root);
+}
+
+function subgraphWorkspaceRoot(root) {
+  return getAddon().subgraphWorkspaceRoot(root);
+}
+
+function subgraphScriptsWriting(dir, needle) {
+  return getAddon().subgraphScriptsWriting(dir, needle);
+}
+
 function runCli(args) {
   let addon = getAddon();
   return addon.runCli(args, envioPackageDir);
@@ -251,8 +325,23 @@ export {
   loadAddon,
   addonRef,
   getAddon,
+  portsServedHere,
   getConfigJson,
   fromUserApi,
+  fromSubgraph,
+  subgraphFileToJavascript,
+  subgraphRegisterHandlers,
+  subgraphSureCreates,
+  subgraphKeccak256,
+  subgraphAbiDecode,
+  subgraphAbiEncodeCall,
+  subgraphBundledCodegen,
+  subgraphBundledCodegenCurrent,
+  subgraphMissingGraphCliMessage,
+  subgraphFillGenerated,
+  subgraphWorkspacePackages,
+  subgraphWorkspaceRoot,
+  subgraphScriptsWriting,
   runCli,
 }
 /* envioPackageDir Not a pure module */

package/src/CrossChainState.res

@@ -24,11 +24,21 @@ type t = {
   mutable holdRealtime: bool,
 }
 
-// The whole-indexer fetch buffer pool, independent of chain count.
+// The whole-indexer fetch buffer pool, independent of chain count. A subgraph
+// with templates keeps far more per fetched event than a handler run does: a
+// register pass with its pending contract calls, and (for a chain kept open by
+// a template) responses well past the block the handlers are at. Venus on BSC
+// held 100k of them and its heap passed 4 GB, so the default there is a tenth
+// of that. Without templates there is neither, and a pool that small leaves
+// one query in flight at a time: fetching stops overlapping processing.
+let defaultSubgraphTargetBufferSize = 10_000
 let calculateTargetBufferSize = () =>
   switch Env.targetBufferSize {
   | Some(size) => size
-  | None => 100_000
+  | None =>
+    Env.subgraphMode.contents && Env.subgraphHasTemplates.contents
+      ? defaultSubgraphTargetBufferSize
+      : 100_000
   }
 
 let make = (

package/src/CrossChainState.res.mjs

@@ -15,15 +15,15 @@ import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 function calculateTargetBufferSize() {
   if (Env.targetBufferSize !== undefined) {
     return Env.targetBufferSize;
+  } else if (Env.subgraphMode.contents && Env.subgraphHasTemplates.contents) {
+    return 10000;
   } else {
     return 100000;
   }
 }
 
 function make(chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt) {
-  let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
-      Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
-    );
+  let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : calculateTargetBufferSize();
   let holdRealtime = holdRealtimeOpt !== undefined ? holdRealtimeOpt : false;
   return {
     chainStates: chainStates,

package/src/Ecosystem.res

@@ -85,6 +85,12 @@ let loggerForItem = (item: Internal.item, ~ecosystem: t, ~logger: Logger.t): Log
     )
   }
 
+let makeKeyOnlyBlock = (~blockNumber: int, ~ecosystem: t): Internal.eventBlock => {
+  let keyOnly = Dict.make()
+  keyOnly->Dict.set(ecosystem.blockNumberName, blockNumber->(Utils.magic: int => unknown))
+  keyOnly->(Utils.magic: dict<unknown> => Internal.eventBlock)
+}
+
 // `block` is the item's materialised selection, which already carries the key;
 // without one the handler selected nothing but the key.
 let makeOnBlockArgs = (
@@ -98,10 +104,7 @@ let makeOnBlockArgs = (
   | Evm | Fuel =>
     let block = switch block {
     | Some(block) => block
-    | None =>
-      let keyOnly = Dict.make()
-      keyOnly->Dict.set(ecosystem.blockNumberName, blockNumber->(Utils.magic: int => unknown))
-      keyOnly->(Utils.magic: dict<unknown> => Internal.eventBlock)
+    | None => makeKeyOnlyBlock(~blockNumber, ~ecosystem)
     }
     {block, context}
   }

package/src/Ecosystem.res.mjs

@@ -23,6 +23,12 @@ function loggerForItem(item, ecosystem, logger) {
   }
 }
 
+function makeKeyOnlyBlock(blockNumber, ecosystem) {
+  let keyOnly = {};
+  keyOnly[ecosystem.blockNumberName] = blockNumber;
+  return keyOnly;
+}
+
 function makeOnBlockArgs(blockNumber, block, ecosystem, context) {
   let match = ecosystem.name;
   switch (match) {
@@ -36,14 +42,7 @@ function makeOnBlockArgs(blockNumber, block, ecosystem, context) {
         context: context
       };
   }
-  let block$1;
-  if (block !== undefined) {
-    block$1 = Primitive_option.valFromOption(block);
-  } else {
-    let keyOnly = {};
-    keyOnly[ecosystem.blockNumberName] = blockNumber;
-    block$1 = keyOnly;
-  }
+  let block$1 = block !== undefined ? Primitive_option.valFromOption(block) : makeKeyOnlyBlock(blockNumber, ecosystem);
   return {
     block: Primitive_option.some(block$1),
     context: context
@@ -53,6 +52,7 @@ function makeOnBlockArgs(blockNumber, block, ecosystem, context) {
 export {
   getItemEvent,
   loggerForItem,
+  makeKeyOnlyBlock,
   makeOnBlockArgs,
 }
 /* Logger Not a pure module */