envio 3.9.0 → 3.10.0

package/src/MemoryStorage.res.mjs

@@ -1,586 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Table from "./db/Table.res.mjs";
-import * as Utils from "./Utils.res.mjs";
-import * as Config from "./Config.res.mjs";
-import * as ChainId from "./ChainId.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
-import * as Internal from "./Internal.res.mjs";
-import * as ChainState from "./ChainState.res.mjs";
-import * as AddressRows from "./AddressRows.res.mjs";
-import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
-import * as EntityFilter from "./db/EntityFilter.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as InternalTable from "./db/InternalTable.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
-
-function make() {
-  return {
-    entities: {},
-    entityConfigs: {},
-    history: {},
-    checkpoints: [],
-    chains: {},
-    cache: {},
-    effectCache: {},
-    envioInfo: undefined,
-    addresses: AddressRows.Table.make(),
-    isInitialized: false
-  };
-}
-
-function rowKey(scope, entityId) {
-  if (scope === "crossChain") {
-    return EntityId.toKey(entityId);
-  } else {
-    return ChainId.toString(scope) + `|` + EntityId.toKey(entityId);
-  }
-}
-
-let historyKey = rowKey;
-
-function readChainId(entity, field) {
-  return entity[field.fieldName];
-}
-
-function copyEntity(entity) {
-  return Utils.Dict.shallowCopy(entity);
-}
-
-function getEntityDict(state, name) {
-  let dict = state.entities[name];
-  if (dict !== undefined) {
-    return dict;
-  }
-  let dict$1 = {};
-  state.entities[name] = dict$1;
-  return dict$1;
-}
-
-function getHistory(state, name) {
-  let rows = state.history[name];
-  if (rows !== undefined) {
-    return rows;
-  }
-  let rows$1 = [];
-  state.history[name] = rows$1;
-  return rows$1;
-}
-
-function registerEntities(state, entities) {
-  entities.forEach(entityConfig => {
-    state.entityConfigs[entityConfig.name] = entityConfig;
-    state.entityConfigs[entityConfig.table.tableName] = entityConfig;
-    getEntityDict(state, entityConfig.name);
-  });
-}
-
-function seedConfigAddresses(state, chainConfigs, contractMapping, ecosystem) {
-  AddressRows.Table.clear(state.addresses);
-  ChainState.seedConfigAddresses(state.addresses, chainConfigs, ecosystem, contractMapping);
-}
-
-function addressRowsByChain(state) {
-  return AddressRows.Table.groupByChain(state.addresses);
-}
-
-function toInitialChainStates(state) {
-  let addressesByChain = AddressRows.Table.groupByChain(state.addresses);
-  return Object.values(state.chains).map(chain => ({
-    id: chain.id,
-    startBlock: chain.startBlock,
-    endBlock: chain.endBlock,
-    maxReorgDepth: chain.maxReorgDepth,
-    progressBlockNumber: chain.progressBlockNumber,
-    numEventsProcessed: chain.numEventsProcessed,
-    firstEventBlockNumber: chain.firstEventBlockNumber,
-    timestampCaughtUpToHeadOrEndblock: chain.timestampCaughtUpToHeadOrEndblock,
-    addressRows: Stdlib_Option.getOr(addressesByChain[ChainId.toString(chain.id)], AddressRows.emptySeedRows()),
-    sourceBlockNumber: chain.sourceBlockNumber
-  }));
-}
-
-function committedCheckpointId(state) {
-  return Stdlib_Array.reduce(state.checkpoints, InternalTable.Checkpoints.initialCheckpointId, (max, cp) => {
-    if (cp.id > max) {
-      return cp.id;
-    } else {
-      return max;
-    }
-  });
-}
-
-function reorgCheckpoints(state) {
-  return Stdlib_Array.filterMap(state.checkpoints, cp => {
-    let match = cp.blockHash;
-    let match$1 = state.chains[ChainId.toString(cp.chainId)];
-    if (match === undefined) {
-      return;
-    }
-    if (match$1 === undefined) {
-      return;
-    }
-    let safeBlock = match$1.sourceBlockNumber - match$1.maxReorgDepth | 0;
-    if (match$1.maxReorgDepth > 0 && match$1.progressBlockNumber > safeBlock && cp.blockNumber >= safeBlock) {
-      return {
-        id: cp.id,
-        chain_id: cp.chainId,
-        block_number: cp.blockNumber,
-        block_hash: match
-      };
-    }
-  });
-}
-
-function toInitialState(state, cleanRun, contractMapping) {
-  return {
-    cleanRun: cleanRun,
-    contractMapping: contractMapping,
-    envioInfo: state.envioInfo,
-    cache: state.cache,
-    chains: toInitialChainStates(state),
-    checkpointId: committedCheckpointId(state),
-    reorgCheckpoints: reorgCheckpoints(state)
-  };
-}
-
-function handleLoad(state, tableName, filter) {
-  let entityConfig = state.entityConfigs[tableName];
-  if (entityConfig !== undefined) {
-    let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-    let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
-    let field = Table.getChainIdField(entityConfig.table);
-    if (field !== undefined) {
-      return matched.map(entity => {
-        let copy = Utils.Dict.shallowCopy(entity);
-        Utils.Dict.deleteInPlace(copy, field.fieldName);
-        return copy;
-      });
-    } else {
-      return matched;
-    }
-  }
-  let cacheDict = state.effectCache[tableName];
-  if (cacheDict !== undefined) {
-    return Object.values(cacheDict).filter(item => EntityFilter.matches(filter, item));
-  } else {
-    return [];
-  }
-}
-
-function backfillHistory(state, entityConfig, scope, entityId, rows) {
-  let key = rowKey(scope, entityId);
-  if (rows.some(row => rowKey(row.scope, row.entityId) === key)) {
-    return;
-  }
-  let entity = Stdlib_Option.flatMap(state.entities[entityConfig.name], dict => dict[rowKey(scope, entityId)]);
-  if (entity !== undefined) {
-    rows.push({
-      entityId: entityId,
-      scope: scope,
-      checkpointId: InternalTable.Checkpoints.initialCheckpointId,
-      action: "SET",
-      entity: entity
-    });
-    return;
-  }
-}
-
-function applyRollback(state, targetCheckpointId, rolledBackAddresses) {
-  state.checkpoints = state.checkpoints.filter(cp => cp.id <= targetCheckpointId);
-  rolledBackAddresses.forEach(key => AddressRows.Table.$$delete(state.addresses, key));
-  Object.entries(state.history).forEach(param => {
-    state.history[param[0]] = param[1].filter(row => row.checkpointId <= targetCheckpointId);
-  });
-}
-
-function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, registeredAddresses, updatedEffectsCache, chainMetaData) {
-  let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
-  if (rollback !== undefined) {
-    applyRollback(state, rollback.targetCheckpointId, rollback.rolledBackAddresses);
-  }
-  registeredAddresses.forEach(param => AddressRows.Table.insert(state.addresses, param.row));
-  let diffCheckpointId = Stdlib_Option.map(rollback, param => param.diffCheckpointId);
-  let isDiff = change => {
-    if (diffCheckpointId !== undefined) {
-      return change.checkpointId === diffCheckpointId;
-    } else {
-      return false;
-    }
-  };
-  updatedEntities.forEach(param => {
-    let changes = param.changes;
-    let scope = param.scope;
-    let entityConfig = param.entityConfig;
-    let entityDict = getEntityDict(state, entityConfig.name);
-    let historyRows = getHistory(state, entityConfig.name);
-    let chainIdField = Table.getChainIdField(entityConfig.table);
-    let idsWithDiff = new Set();
-    changes.forEach(change => {
-      if (isDiff(change)) {
-        idsWithDiff.add(EntityId.toKey(change.entityId));
-        return;
-      }
-    });
-    changes.forEach(change => {
-      let entityId = change.entityId;
-      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change);
-      if (shouldSaveHistory && !idsWithDiff.has(EntityId.toKey(entityId))) {
-        backfillHistory(state, entityConfig, scope, entityId, historyRows);
-      }
-      if (change.type === "SET") {
-        let entity = change.entity;
-        let match = Internal.chainScopeChainId(scope);
-        let storedEntity = chainIdField !== undefined && match !== undefined ? Internal.stampChainId(entity, chainIdField.fieldName, Primitive_option.valFromOption(match)) : entity;
-        entityDict[rowKey(scope, entityId)] = storedEntity;
-        if (shouldSaveChangeHistory) {
-          historyRows.push({
-            entityId: entityId,
-            scope: scope,
-            checkpointId: change.checkpointId,
-            action: "SET",
-            entity: storedEntity
-          });
-          return;
-        } else {
-          return;
-        }
-      }
-      Utils.Dict.deleteInPlace(entityDict, rowKey(scope, entityId));
-      if (shouldSaveChangeHistory) {
-        historyRows.push({
-          entityId: entityId,
-          scope: scope,
-          checkpointId: change.checkpointId,
-          action: "DELETE",
-          entity: undefined
-        });
-        return;
-      }
-    });
-  });
-  Object.values(batch.progressedChainsById).forEach(chainAfterBatch => {
-    let key = ChainId.toString(chainAfterBatch.fetchState.chainId);
-    let chain = state.chains[key];
-    if (chain !== undefined) {
-      chain.progressBlockNumber = chainAfterBatch.progressBlockNumber;
-      chain.sourceBlockNumber = chainAfterBatch.sourceBlockNumber;
-      chain.numEventsProcessed = chainAfterBatch.totalEventsProcessed;
-      return;
-    }
-  });
-  if (chainMetaData !== undefined) {
-    Object.entries(chainMetaData).forEach(param => {
-      let meta = param[1];
-      let chain = state.chains[param[0]];
-      if (chain !== undefined) {
-        chain.firstEventBlockNumber = Primitive_option.fromNull(meta.first_event_block);
-        chain.latestFetchedBlockNumber = meta.buffer_block;
-        chain.timestampCaughtUpToHeadOrEndblock = Primitive_option.fromNull(meta.ready_at);
-        return;
-      }
-    });
-  }
-  if (shouldSaveHistory) {
-    for (let i = 0, i_finish = batch.checkpointIds.length; i < i_finish; ++i) {
-      state.checkpoints.push({
-        id: batch.checkpointIds[i],
-        chainId: batch.checkpointChainIds[i],
-        blockNumber: batch.checkpointBlockNumbers[i],
-        blockHash: Primitive_option.fromNull(batch.checkpointBlockHashes[i]),
-        eventsProcessed: batch.checkpointEventsProcessed[i]
-      });
-    }
-  }
-  updatedEffectsCache.forEach(param => {
-    let table = param.table;
-    let dict = state.effectCache[table.tableName];
-    let cacheDict;
-    if (dict !== undefined) {
-      cacheDict = dict;
-    } else {
-      let dict$1 = {};
-      state.effectCache[table.tableName] = dict$1;
-      cacheDict = dict$1;
-    }
-    param.items.forEach(item => {
-      cacheDict[item.id] = item;
-    });
-    let record = state.cache[table.tableName];
-    if (record !== undefined) {
-      record.count = Object.keys(cacheDict).length;
-      return;
-    }
-  });
-}
-
-function getRollbackData(state, entityConfig, rollbackTargetCheckpointId) {
-  let rows = Stdlib_Option.getOr(state.history[entityConfig.name], []);
-  let changedKeys = {};
-  rows.forEach(row => {
-    if (row.checkpointId > rollbackTargetCheckpointId) {
-      changedKeys[rowKey(row.scope, row.entityId)] = row;
-      return;
-    }
-  });
-  let removals = [];
-  let restored = [];
-  Object.entries(changedKeys).forEach(param => {
-    let changedRow = param[1];
-    let key = param[0];
-    let preTarget = Stdlib_Array.reduce(rows, undefined, (latest, row) => {
-      if (rowKey(row.scope, row.entityId) === key && row.checkpointId <= rollbackTargetCheckpointId && !(latest !== undefined && latest.checkpointId >= row.checkpointId)) {
-        return row;
-      } else {
-        return latest;
-      }
-    });
-    if (preTarget !== undefined) {
-      if (preTarget.action === "SET") {
-        let entity = preTarget.entity;
-        if (entity !== undefined) {
-          restored.push(entity);
-          return;
-        } else {
-          return;
-        }
-      }
-      removals.push({
-        entityId: preTarget.entityId,
-        scope: preTarget.scope
-      });
-      return;
-    }
-    removals.push({
-      entityId: changedRow.entityId,
-      scope: changedRow.scope
-    });
-  });
-  return [
-    removals,
-    restored
-  ];
-}
-
-function getRollbackProgressDiff(state, rollbackTargetCheckpointId) {
-  let byChain = {};
-  state.checkpoints.forEach(cp => {
-    if (cp.id <= rollbackTargetCheckpointId) {
-      return;
-    }
-    let key = ChainId.toString(cp.chainId);
-    let acc = byChain[key];
-    if (acc !== undefined) {
-      acc.eventsProcessed = acc.eventsProcessed + cp.eventsProcessed | 0;
-      acc.newProgressBlockNumber = Math.min(acc.newProgressBlockNumber, cp.blockNumber - 1 | 0);
-    } else {
-      byChain[key] = {
-        chainId: cp.chainId,
-        eventsProcessed: cp.eventsProcessed,
-        newProgressBlockNumber: cp.blockNumber - 1 | 0
-      };
-    }
-  });
-  return Object.values(byChain).map(acc => ({
-    chain_id: acc.chainId,
-    events_processed_diff: acc.eventsProcessed.toString(),
-    new_progress_block_number: acc.newProgressBlockNumber
-  }));
-}
-
-function toStorage(state, config) {
-  return {
-    name: "memory",
-    isInitialized: async () => state.isInitialized,
-    initialize: async (chainConfigsOpt, entitiesOpt, $staropt$star, contractMapping, envioInfo) => {
-      let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
-      let entities = entitiesOpt !== undefined ? entitiesOpt : [];
-      $staropt$star !== undefined;
-      registerEntities(state, entities);
-      seedConfigAddresses(state, chainConfigs, contractMapping, config.ecosystem.name);
-      chainConfigs.forEach(chainConfig => {
-        state.chains[ChainId.toString(chainConfig.id)] = {
-          id: chainConfig.id,
-          startBlock: chainConfig.startBlock,
-          endBlock: chainConfig.endBlock,
-          maxReorgDepth: chainConfig.maxReorgDepth,
-          progressBlockNumber: -1,
-          sourceBlockNumber: 0,
-          numEventsProcessed: 0,
-          firstEventBlockNumber: undefined,
-          latestFetchedBlockNumber: 0,
-          timestampCaughtUpToHeadOrEndblock: undefined
-        };
-      });
-      state.envioInfo = envioInfo;
-      state.isInitialized = true;
-      return toInitialState(state, true, contractMapping);
-    },
-    resumeInitialState: async () => toInitialState(state, false, config.contractMapping),
-    loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
-    ensureQueryIndexes: async (param, param$1) => {},
-    ensureSchemaIndexes: async param => {},
-    finalizeBackfill: async (param, chainIds, readyAt) => {
-      chainIds.forEach(chainId => {
-        let chain = state.chains[ChainId.toString(chainId)];
-        if (chain !== undefined) {
-          chain.timestampCaughtUpToHeadOrEndblock = readyAt;
-          return;
-        }
-      });
-    },
-    dumpEffectCache: async () => {},
-    reset: async () => {
-      let clear = Utils.Dict.clearInPlace;
-      clear(state.entities);
-      clear(state.history);
-      clear(state.chains);
-      clear(state.effectCache);
-      clear(state.cache);
-      state.checkpoints = [];
-      AddressRows.Table.clear(state.addresses);
-      state.envioInfo = undefined;
-      state.isInitialized = false;
-    },
-    setChainMeta: async chainsData => {
-      Object.entries(chainsData).forEach(param => {
-        let meta = param[1];
-        let chain = state.chains[param[0]];
-        if (chain !== undefined) {
-          chain.firstEventBlockNumber = Primitive_option.fromNull(meta.first_event_block);
-          chain.latestFetchedBlockNumber = meta.buffer_block;
-          chain.timestampCaughtUpToHeadOrEndblock = Primitive_option.fromNull(meta.ready_at);
-          return;
-        }
-      });
-      return undefined;
-    },
-    pruneStaleCheckpoints: async safeCheckpointId => {
-      state.checkpoints = state.checkpoints.filter(cp => cp.id >= safeCheckpointId);
-    },
-    pruneStaleEntityHistory: async (entityName, param, param$1, safeCheckpointId) => {
-      let rows = state.history[entityName];
-      if (rows === undefined) {
-        return;
-      }
-      let newestBelow = {};
-      rows.forEach(row => {
-        if (row.checkpointId >= safeCheckpointId) {
-          return;
-        }
-        let key = rowKey(row.scope, row.entityId);
-        let current = newestBelow[key];
-        if (current !== undefined && current.checkpointId >= row.checkpointId) {
-          return;
-        } else {
-          newestBelow[key] = row;
-          return;
-        }
-      });
-      state.history[entityName] = rows.filter(row => {
-        let key = rowKey(row.scope, row.entityId);
-        if (row.checkpointId >= safeCheckpointId) {
-          return true;
-        }
-        let kept = newestBelow[key];
-        if (kept !== undefined) {
-          return kept === row;
-        } else {
-          return false;
-        }
-      });
-    },
-    getRollbackTargetCheckpoint: async (reorgChainId, lastKnownValidBlockNumber) => Stdlib_Array.reduce(state.checkpoints, undefined, (target, cp) => {
-      if (Primitive_object.equal(cp.chainId, reorgChainId) && cp.blockNumber <= lastKnownValidBlockNumber && !(target !== undefined && target >= cp.id)) {
-        return cp.id;
-      } else {
-        return target;
-      }
-    }),
-    getRollbackProgressDiff: async rollbackTargetCheckpointId => getRollbackProgressDiff(state, rollbackTargetCheckpointId),
-    getRollbackData: async (entityConfig, rollbackTargetCheckpointId) => getRollbackData(state, entityConfig, rollbackTargetCheckpointId),
-    writeBatch: async (batch, rollback, isInReorgThreshold, param, param$1, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, param$2) => writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, registeredAddresses, updatedEffectsCache, chainMetaData),
-    close: async () => {}
-  };
-}
-
-function currentRows(state, entityConfig) {
-  return Object.values(Stdlib_Option.getOr(state.entities[entityConfig.name], {}));
-}
-
-function historyChanges(state, entityConfig) {
-  return Stdlib_Option.getOr(state.history[entityConfig.name], []).map(row => {
-    let match = row.action;
-    if (match === "SET") {
-      return {
-        type: "SET",
-        entityId: row.entityId,
-        entity: Stdlib_Option.getOr(row.entity, {}),
-        checkpointId: row.checkpointId
-      };
-    } else {
-      return {
-        type: "DELETE",
-        entityId: row.entityId,
-        checkpointId: row.checkpointId
-      };
-    }
-  }).toSorted((a, b) => {
-    let order = Primitive_string.compare(EntityId.toKey(a.entityId), EntityId.toKey(b.entityId));
-    if (order !== 0) {
-      return order;
-    } else {
-      return Primitive_float.compare(Number(a.checkpointId), Number(b.checkpointId));
-    }
-  });
-}
-
-function checkpointRows(state) {
-  return state.checkpoints.map(cp => ({
-    id: cp.id,
-    chain_id: cp.chainId,
-    block_number: cp.blockNumber,
-    block_hash: Stdlib_Null.fromOption(cp.blockHash),
-    events_processed: cp.eventsProcessed
-  }));
-}
-
-function effectCacheRows(state, tableName) {
-  return Object.values(Stdlib_Option.getOr(state.effectCache[tableName], {})).map(item => ({
-    id: item.id,
-    output: item.output
-  }));
-}
-
-export {
-  make,
-  rowKey,
-  historyKey,
-  readChainId,
-  copyEntity,
-  getEntityDict,
-  getHistory,
-  registerEntities,
-  seedConfigAddresses,
-  addressRowsByChain,
-  toInitialChainStates,
-  committedCheckpointId,
-  reorgCheckpoints,
-  toInitialState,
-  handleLoad,
-  backfillHistory,
-  applyRollback,
-  writeBatch,
-  getRollbackData,
-  getRollbackProgressDiff,
-  toStorage,
-  currentRows,
-  historyChanges,
-  checkpointRows,
-  effectCacheRows,
-}
-/* Table Not a pure module */

package/src/sources/HyperSyncHeightStream.res

@@ -1,129 +0,0 @@
-/*
-Pure subscription-based implementation of the HyperSync height stream.
-*/
-
-let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (unit => unit) => {
-  let eventsourceRef = ref(None)
-  let errorCount = ref(0)
-  let baseDuration = 50
-  // Timeout doesn't do anything for initialization
-  let timeoutIdRef = ref(setTimeout(() => (), 0))
-
-  // On every successful ping or height event, clear the timeout and set a new one.
-  // If the timeout lapses, close and reconnect the EventSource.
-  let rec updateTimeoutId = () => {
-    timeoutIdRef.contents->clearTimeout
-
-    // Should receive a ping at least every 5s, so 15s is a safe margin
-    // for staleness to restart the EventSource connection
-    let staleTimeMillis = 15_000
-    let newTimeoutId = setTimeout(() => {
-      Logging.trace({
-        "msg": "Timeout fired for height stream",
-        "chainId": chainId,
-        "url": hyperSyncUrl,
-        "staleTimeMillis": staleTimeMillis,
-      })
-      refreshEventSource()
-    }, staleTimeMillis)
-
-    timeoutIdRef := newTimeoutId
-  }
-  // Instantiate a new EventSource and set it to the shared refs.
-  // Add the necessary event listeners, handle errors
-  // and update the timeout.
-  and scheduleReconnect = () => {
-    // Clear any pending stale/reconnect timeout to avoid double reconnect
-    timeoutIdRef.contents->clearTimeout
-    let delay = baseDuration * Math.pow(2.0, ~exp=errorCount.contents->Int.toFloat)->Float.toInt
-    timeoutIdRef := setTimeout(() => refreshEventSource(), Pervasives.min(delay, 60_000))
-  }
-  and refreshEventSource = () => {
-    // Close the old EventSource if it exists (on a new connection after timeout)
-    switch eventsourceRef.contents {
-    | Some(es) => es->EventSource.close
-    | None => ()
-    }
-
-    let userAgent = `hyperindex/${Utils.EnvioPackage.value.version}`
-    let es = EventSource.create(
-      ~url=`${hyperSyncUrl}/height/sse`,
-      ~options={
-        fetch: (url, ~args) => {
-          EventSource.Fetch.fetch(
-            url,
-            ~args={
-              ...args,
-              headers: Dict.fromArray([
-                ("Authorization", `Bearer ${apiToken}`),
-                ("User-Agent", userAgent),
-              ]),
-            },
-          )
-        },
-      },
-    )
-
-    // Set the new EventSource to the shared ref
-    eventsourceRef := Some(es)
-    // Update the timeout in case connection goes stale
-    updateTimeoutId()
-
-    es->EventSource.onopen(_ => {
-      errorCount := 0
-      Logging.trace({
-        "msg": "SSE connection opened for height stream",
-        "chainId": chainId,
-        "url": hyperSyncUrl,
-      })
-    })
-
-    es->EventSource.onerror(error => {
-      errorCount := errorCount.contents + 1
-      Logging.trace({
-        "msg": "EventSource error on height stream, reconnecting",
-        "chainId": chainId,
-        "url": hyperSyncUrl,
-        "status": error.status,
-        "error": error.message,
-        "errorCount": errorCount.contents,
-      })
-      scheduleReconnect()
-    })
-
-    es->EventSource.addEventListener("ping", _event => {
-      // ping lets us know from the server that the connection is still alive
-      // and that the height hasn't updated for 5 seconds
-      // update the timeout on each successful ping received
-      updateTimeoutId()
-    })
-
-    es->EventSource.addEventListener("height", event => {
-      switch event.data->Int.fromString {
-      | Some(height) =>
-        // On a successful height event, update the timeout
-        updateTimeoutId()
-        // Call the callback with the new height
-        onHeight(height)
-      | None =>
-        Logging.trace({
-          "msg": "Height was not a number in event.data",
-          "chainId": chainId,
-          "data": event.data,
-        })
-      }
-    })
-  }
-
-  // Start the EventSource connection
-  refreshEventSource()
-
-  // Return unsubscribe function
-  () => {
-    timeoutIdRef.contents->clearTimeout
-    switch eventsourceRef.contents {
-    | Some(es) => es->EventSource.close
-    | None => ()
-    }
-  }
-}