envio 3.3.0-alpha.4 → 3.3.0-alpha.5

package/src/IndexingAddresses.res.mjs

@@ -0,0 +1,100 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
+  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
+}
+
+function makeContractConfigs(eventConfigs) {
+  let contractConfigs = {};
+  eventConfigs.forEach(ec => {
+    let match = contractConfigs[ec.contractName];
+    if (match !== undefined) {
+      let startBlock = match.startBlock;
+      let match$1 = ec.startBlock;
+      contractConfigs[ec.contractName] = {
+        startBlock: startBlock !== undefined ? (
+            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
+          ) : (
+            match$1 !== undefined ? match$1 : undefined
+          )
+      };
+      return;
+    }
+    contractConfigs[ec.contractName] = {
+      startBlock: ec.startBlock
+    };
+  });
+  return contractConfigs;
+}
+
+function makeIndexingAddress(contract, contractConfigs) {
+  let match = contractConfigs[contract.contractName];
+  let contractStartBlock = match !== undefined ? match.startBlock : undefined;
+  return {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock)
+  };
+}
+
+function make(contractConfigs, addresses) {
+  let indexingAddresses = {};
+  addresses.forEach(contract => {
+    indexingAddresses[contract.address] = makeIndexingAddress(contract, contractConfigs);
+  });
+  return indexingAddresses;
+}
+
+function get(indexingAddresses, address) {
+  return indexingAddresses[address];
+}
+
+function size(indexingAddresses) {
+  return Utils.Dict.size(indexingAddresses);
+}
+
+function getContractAddresses(indexingAddresses, contractName) {
+  let addresses = [];
+  Utils.Dict.forEach(indexingAddresses, ia => {
+    if (ia.contractName === contractName) {
+      addresses.push(ia.address);
+      return;
+    }
+  });
+  return addresses;
+}
+
+function rawForFilter(indexingAddresses) {
+  return indexingAddresses;
+}
+
+function register(indexingAddresses, additions) {
+  Object.assign(indexingAddresses, additions);
+}
+
+function rollbackInPlace(indexingAddresses, targetBlockNumber) {
+  Utils.Dict.forEachWithKey(indexingAddresses, (indexingContract, address) => {
+    if (indexingContract.registrationBlock > targetBlockNumber) {
+      return Utils.Dict.deleteInPlace(indexingAddresses, address);
+    }
+  });
+}
+
+export {
+  deriveEffectiveStartBlock,
+  makeContractConfigs,
+  makeIndexingAddress,
+  make,
+  get,
+  size,
+  getContractAddresses,
+  rawForFilter,
+  register,
+  rollbackInPlace,
+}
+/* Utils Not a pure module */

package/src/IndexingAddresses.resi

@@ -0,0 +1,32 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t
+
+let deriveEffectiveStartBlock: (~registrationBlock: int, ~contractStartBlock: option<int>) => int
+
+let makeContractConfigs: (~eventConfigs: array<Internal.eventConfig>) => dict<contractConfig>
+
+let makeIndexingAddress: (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+) => indexingAddress
+
+let make: (~contractConfigs: dict<contractConfig>, ~addresses: array<Internal.indexingAddress>) => t
+
+let get: (t, string) => option<indexingAddress>
+
+let size: t => int
+
+let getContractAddresses: (t, ~contractName: string) => array<Address.t>
+
+// Underlying dict for the precompiled `clientAddressFilter` only, which does raw
+// `indexingAddresses[srcAddress]` access in generated JS. Don't use elsewhere —
+// prefer the domain accessors so the opaque type stays enforced.
+let rawForFilter: t => dict<indexingAddress>
+
+let register: (t, dict<indexingAddress>) => unit
+
+// Deletes addresses registered after `targetBlockNumber` from the index in place.
+let rollbackInPlace: (t, ~targetBlockNumber: int) => unit

package/src/Main.res

@@ -168,18 +168,7 @@ let buildChainsObject = (~config: Config.t) => {
             | Some(state) => {
                 let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
                 let chainState = state->IndexerState.getChainState(~chain)
-                let indexingAddresses = chainState->ChainState.indexingAddresses
-
-                // Collect all addresses for this contract name from indexingAddresses
-                let addresses = []
-                let values = indexingAddresses->Dict.valuesToArray
-                for idx in 0 to values->Array.length - 1 {
-                  let indexingContract = values->Array.getUnsafe(idx)
-                  if indexingContract.contractName === contract.name {
-                    addresses->Array.push(indexingContract.address)->ignore
-                  }
-                }
-                addresses
+                chainState->ChainState.contractAddresses(~contractName=contract.name)
               }
             // Before the global state is available (eg during handler
             // module load after resume), combine static addresses from config
@@ -627,9 +616,9 @@ let startServer = (~getState, ~persistence: Persistence.t, ~isDevelopmentMode: b
   app->get("/metrics", (_req, res) => {
     res->set("Content-Type", PromClient.defaultRegister->PromClient.getContentType)
     let _ =
-      PromClient.defaultRegister
-      ->PromClient.metrics
-      ->Promise.thenResolve(metrics => res->endWithData(metrics))
+      Metrics.collect(~state=indexerStateRef.contents)->Promise.thenResolve(metrics =>
+        res->endWithData(metrics)
+      )
   })
 
   app->get("/metrics/runtime", (_req, res) => {

package/src/Main.res.mjs

@@ -6,6 +6,7 @@ import * as Envio from "./Envio.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Metrics from "./Metrics.res.mjs";
 import Express from "express";
 import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
@@ -165,29 +166,20 @@ function buildChainsObject(config) {
           if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
-            let indexingAddresses = ChainState.indexingAddresses(chainState);
-            let addresses = [];
-            let values = Object.values(indexingAddresses);
-            for (let idx = 0, idx_finish = values.length; idx < idx_finish; ++idx) {
-              let indexingContract = values[idx];
-              if (indexingContract.contractName === contract.name) {
-                addresses.push(indexingContract.address);
-              }
-            }
-            return addresses;
+            return ChainState.contractAddresses(chainState, contract.name);
           }
           let chainState$1 = getInitialChainState(chainConfig.id);
           if (chainState$1 === undefined) {
             return contract.addresses;
           }
-          let addresses$1 = contract.addresses.slice();
+          let addresses = contract.addresses.slice();
           chainState$1.indexingAddresses.forEach(dc => {
             if (dc.contractName === contract.name) {
-              addresses$1.push(dc.address);
+              addresses.push(dc.address);
               return;
             }
           });
-          return addresses$1;
+          return addresses;
         }
       });
       Object.defineProperty(chainObj, contract.name, {
@@ -486,7 +478,7 @@ function startServer(getState, persistence, isDevelopmentMode) {
   });
   app.get("/metrics", (_req, res) => {
     res.set("Content-Type", PromClient.register.contentType);
-    PromClient.register.metrics().then(metrics => res.end(metrics));
+    Metrics.collect(indexerStateRef.contents).then(metrics => res.end(metrics));
   });
   app.get("/metrics/runtime", (_req, res) => {
     res.set("Content-Type", runtimeRegistry.contentType);

package/src/Metrics.res

@@ -0,0 +1,33 @@
+// Pull-based metrics computed from live indexer state at scrape time, merged with
+// the imperatively-updated prom-client default registry. Used because the address
+// index is mutated in place (no single update site to fire a gauge from).
+
+let indexingAddressesName = "envio_indexing_addresses"
+let indexingAddressesHelp = "The number of addresses indexed on chain. Includes both static and dynamic addresses."
+
+// Render a gauge straight from the per-chain dict, one sample per key, without
+// materialising an intermediate samples array. Accumulate into one string rather
+// than building a lines array to join: `++` compiles to JS `+=`, which V8 grows
+// as a ConsString instead of recopying.
+let renderGauge = (~name, ~help, ~chains: dict<'a>, ~value: 'a => int) => {
+  let out = ref(`# HELP ${name} ${help}\n# TYPE ${name} gauge`)
+  let prefix = `\n${name}{chainId="`
+  chains->Utils.Dict.forEachWithKey((chain, chainId) => {
+    out := out.contents ++ prefix ++ chainId ++ `"} ` ++ value(chain)->Int.toString
+  })
+  out.contents
+}
+
+let collect = async (~state: option<IndexerState.t>) => {
+  let base = await PromClient.defaultRegister->PromClient.metrics
+  switch state {
+  | None => base
+  | Some(state) =>
+    `${base}${renderGauge(
+        ~name=indexingAddressesName,
+        ~help=indexingAddressesHelp,
+        ~chains=state->IndexerState.chainStates,
+        ~value=cs => (cs->ChainState.toChainData).numAddresses,
+      )}\n`
+  }
+}

package/src/Metrics.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as PromClient from "prom-client";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let indexingAddressesName = "envio_indexing_addresses";
+
+let indexingAddressesHelp = "The number of addresses indexed on chain. Includes both static and dynamic addresses.";
+
+function renderGauge(name, help, chains, value) {
+  let out = {
+    contents: `# HELP ` + name + ` ` + help + `\n# TYPE ` + name + ` gauge`
+  };
+  let prefix = `\n` + name + `{chainId="`;
+  Utils.Dict.forEachWithKey(chains, (chain, chainId) => {
+    out.contents = out.contents + prefix + chainId + `"} ` + value(chain).toString();
+  });
+  return out.contents;
+}
+
+async function collect(state) {
+  let base = await PromClient.register.metrics();
+  if (state !== undefined) {
+    return base + renderGauge(indexingAddressesName, indexingAddressesHelp, IndexerState.chainStates(Primitive_option.valFromOption(state)), cs => ChainState.toChainData(cs).numAddresses) + `\n`;
+  } else {
+    return base;
+  }
+}
+
+export {
+  indexingAddressesName,
+  indexingAddressesHelp,
+  renderGauge,
+  collect,
+}
+/* Utils Not a pure module */

package/src/Prometheus.res

@@ -246,10 +246,7 @@ module PreloadHandler = {
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
-    sumTimeCounter->SafeCounter.handleFloat(
-      ~labels,
-      ~value=timerRef->Performance.secondsSince,
-    )
+    sumTimeCounter->SafeCounter.handleFloat(~labels, ~value=timerRef->Performance.secondsSince)
     count->SafeCounter.increment(~labels)
   }
 }
@@ -339,18 +336,6 @@ module ProcessStartTimeSeconds = {
   }
 }
 
-module IndexingAddresses = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_indexing_addresses",
-    ~help="The number of addresses indexed on chain. Includes both static and dynamic addresses.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~addressesCount, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=addressesCount)
-  }
-}
-
 module IndexingConcurrency = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_indexing_concurrency",
@@ -800,10 +785,7 @@ module StorageLoad = {
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
-    sumTimeCounter->SafeCounter.handleFloat(
-      ~labels,
-      ~value=timerRef->Performance.secondsSince,
-    )
+    sumTimeCounter->SafeCounter.handleFloat(~labels, ~value=timerRef->Performance.secondsSince)
     counter->SafeCounter.increment(~labels)
     whereSizeCounter->SafeCounter.handleInt(~labels, ~value=whereSize)
     sizeCounter->SafeCounter.handleInt(~labels, ~value=size)

package/src/Prometheus.res.mjs

@@ -389,39 +389,28 @@ let ProcessStartTimeSeconds = {
   set: set$3
 };
 
-let gauge$4 = makeOrThrow$1("envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", chainIdLabelsSchema);
+let gauge$4 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$4(addressesCount, chainId) {
-  handleInt$1(gauge$4, chainId, addressesCount);
+function set$4(concurrency, chainId) {
+  handleInt$1(gauge$4, chainId, concurrency);
 }
 
-let IndexingAddresses = {
+let IndexingConcurrency = {
   gauge: gauge$4,
   set: set$4
 };
 
-let gauge$5 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
+let gauge$5 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
 
-function set$5(concurrency, chainId) {
-  handleInt$1(gauge$5, chainId, concurrency);
+function set$5(partitionsCount, chainId) {
+  handleInt$1(gauge$5, chainId, partitionsCount);
 }
 
-let IndexingConcurrency = {
+let IndexingPartitions = {
   gauge: gauge$5,
   set: set$5
 };
 
-let gauge$6 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
-
-function set$6(partitionsCount, chainId) {
-  handleInt$1(gauge$6, chainId, partitionsCount);
-}
-
-let IndexingPartitions = {
-  gauge: gauge$6,
-  set: set$6
-};
-
 let counter = makeOrThrow("envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
 
 let IndexingIdleTime = {
@@ -440,51 +429,51 @@ let IndexingQueryTime = {
   counter: counter$2
 };
 
-let gauge$7 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
+let gauge$6 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
 
-function set$7(bufferSize, chainId) {
-  handleInt$1(gauge$7, chainId, bufferSize);
+function set$6(bufferSize, chainId) {
+  handleInt$1(gauge$6, chainId, bufferSize);
 }
 
 let IndexingBufferSize = {
-  gauge: gauge$7,
-  set: set$7
+  gauge: gauge$6,
+  set: set$6
 };
 
-let gauge$8 = PromClient.Gauge.makeGauge({
+let gauge$7 = PromClient.Gauge.makeGauge({
   name: "envio_indexing_target_buffer_size",
   help: "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
 });
 
-function set$8(targetBufferSize) {
-  gauge$8.set(targetBufferSize);
+function set$7(targetBufferSize) {
+  gauge$7.set(targetBufferSize);
 }
 
 let IndexingTargetBufferSize = {
-  gauge: gauge$8,
-  set: set$8
+  gauge: gauge$7,
+  set: set$7
 };
 
-let gauge$9 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
+let gauge$8 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
 
-function set$9(blockNumber, chainId) {
-  handleInt$1(gauge$9, chainId, blockNumber);
+function set$8(blockNumber, chainId) {
+  handleInt$1(gauge$8, chainId, blockNumber);
 }
 
 let IndexingBufferBlockNumber = {
-  gauge: gauge$9,
-  set: set$9
+  gauge: gauge$8,
+  set: set$8
 };
 
-let gauge$10 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
+let gauge$9 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
 
-function set$10(endBlock, chainId) {
-  handleInt$1(gauge$10, chainId, endBlock);
+function set$9(endBlock, chainId) {
+  handleInt$1(gauge$9, chainId, endBlock);
 }
 
 let IndexingEndBlock = {
-  gauge: gauge$10,
-  set: set$10
+  gauge: gauge$9,
+  set: set$9
 };
 
 let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -525,18 +514,18 @@ let SourceRequestCount = {
   addSeconds: addSeconds
 };
 
-let gauge$11 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
+let gauge$10 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
 
-function set$11(sourceName, chainId, blockNumber) {
-  handleInt$1(gauge$11, {
+function set$10(sourceName, chainId, blockNumber) {
+  handleInt$1(gauge$10, {
     source: sourceName,
     chainId: chainId
   }, blockNumber);
 }
 
 let SourceHeight = {
-  gauge: gauge$11,
-  set: set$11
+  gauge: gauge$10,
+  set: set$10
 };
 
 let counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
@@ -550,43 +539,43 @@ let ReorgCount = {
   increment: increment$5
 };
 
-let gauge$12 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
+let gauge$11 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
 
-function set$12(blockNumber, chain) {
-  handleInt$1(gauge$12, chain, blockNumber);
+function set$11(blockNumber, chain) {
+  handleInt$1(gauge$11, chain, blockNumber);
 }
 
 let ReorgDetectionBlockNumber = {
-  gauge: gauge$12,
-  set: set$12
+  gauge: gauge$11,
+  set: set$11
 };
 
-let gauge$13 = PromClient.Gauge.makeGauge({
+let gauge$12 = PromClient.Gauge.makeGauge({
   name: "envio_reorg_threshold",
   help: "Whether indexing is currently within the reorg threshold"
 });
 
-function set$13(isInReorgThreshold) {
-  gauge$13.set(isInReorgThreshold ? 1 : 0);
+function set$12(isInReorgThreshold) {
+  gauge$12.set(isInReorgThreshold ? 1 : 0);
 }
 
 let ReorgThreshold = {
-  gauge: gauge$13,
-  set: set$13
+  gauge: gauge$12,
+  set: set$12
 };
 
-let gauge$14 = PromClient.Gauge.makeGauge({
+let gauge$13 = PromClient.Gauge.makeGauge({
   name: "envio_rollback_enabled",
   help: "Whether rollback on reorg is enabled"
 });
 
-function set$14(enabled) {
-  gauge$14.set(enabled ? 1 : 0);
+function set$13(enabled) {
+  gauge$13.set(enabled ? 1 : 0);
 }
 
 let RollbackEnabled = {
-  gauge: gauge$14,
-  set: set$14
+  gauge: gauge$13,
+  set: set$13
 };
 
 let timeCounter$3 = PromClient.Counter.makeCounter({
@@ -635,62 +624,62 @@ let RollbackHistoryPrune = {
   increment: increment$7
 };
 
-let gauge$15 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+let gauge$14 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$15(blockNumber, chain) {
-  handleInt$1(gauge$15, chain, blockNumber);
+function set$14(blockNumber, chain) {
+  handleInt$1(gauge$14, chain, blockNumber);
 }
 
 let RollbackTargetBlockNumber = {
-  gauge: gauge$15,
-  set: set$15
+  gauge: gauge$14,
+  set: set$14
 };
 
-let gauge$16 = PromClient.Gauge.makeGauge({
+let gauge$15 = PromClient.Gauge.makeGauge({
   name: "envio_processing_max_batch_size",
   help: "The maximum number of items to process in a single batch."
 });
 
-function set$16(maxBatchSize) {
-  gauge$16.set(maxBatchSize);
+function set$15(maxBatchSize) {
+  gauge$15.set(maxBatchSize);
 }
 
 let ProcessingMaxBatchSize = {
-  gauge: gauge$16,
-  set: set$16
+  gauge: gauge$15,
+  set: set$15
 };
 
-let gauge$17 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+let gauge$16 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$17(blockNumber, chainId) {
-  handleInt$1(gauge$17, chainId, blockNumber);
+function set$16(blockNumber, chainId) {
+  handleInt$1(gauge$16, chainId, blockNumber);
 }
 
 let ProgressBlockNumber = {
-  gauge: gauge$17,
-  set: set$17
+  gauge: gauge$16,
+  set: set$16
 };
 
-let gauge$18 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+let gauge$17 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$18(processedCount, chainId) {
-  handleFloat$1(gauge$18, chainId, processedCount);
+function set$17(processedCount, chainId) {
+  handleFloat$1(gauge$17, chainId, processedCount);
 }
 
 let ProgressEventsCount = {
-  gauge: gauge$18,
-  set: set$18
+  gauge: gauge$17,
+  set: set$17
 };
 
-let gauge$19 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+let gauge$18 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
 
-function set$19(latencyMs, chainId) {
-  handleInt$1(gauge$19, chainId, latencyMs);
+function set$18(latencyMs, chainId) {
+  handleInt$1(gauge$18, chainId, latencyMs);
 }
 
 let ProgressLatency = {
-  gauge: gauge$19,
-  set: set$19
+  gauge: gauge$18,
+  set: set$18
 };
 
 let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSchema.string));
@@ -710,15 +699,15 @@ let EffectCalls = {
   activeCallsCount: activeCallsCount
 };
 
-let gauge$20 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
+let gauge$19 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$20(count, effectName) {
-  handleInt$1(gauge$20, effectName, count);
+function set$19(count, effectName) {
+  handleInt$1(gauge$19, effectName, count);
 }
 
 let EffectCacheCount = {
-  gauge: gauge$20,
-  set: set$20
+  gauge: gauge$19,
+  set: set$19
 };
 
 let counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
@@ -732,18 +721,18 @@ let EffectCacheInvalidationsCount = {
   increment: increment$8
 };
 
-let gauge$21 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
 
 let timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$21(count, effectName) {
-  handleInt$1(gauge$21, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$20, effectName, count);
 }
 
 let EffectQueueCount = {
-  gauge: gauge$21,
+  gauge: gauge$20,
   timeCounter: timeCounter$6,
-  set: set$21
+  set: set$20
 };
 
 let loadLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -846,7 +835,6 @@ export {
   IndexingKnownHeight,
   Info,
   ProcessStartTimeSeconds,
-  IndexingAddresses,
   IndexingConcurrency,
   IndexingPartitions,
   IndexingIdleTime,