envio 3.15.0-subgraph → 3.16.0

package/src/SubgraphLog.res.mjs

@@ -1,26 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let listeners = [];
-
-function onLog(listener) {
-  listeners.push(listener);
-  return () => {
-    let index = listeners.indexOf(listener);
-    if (index !== -1) {
-      listeners.splice(index, 1);
-      return;
-    }
-  };
-}
-
-function notify(level, message) {
-  listeners.forEach(listener => listener(level, message));
-}
-
-export {
-  listeners,
-  onLog,
-  notify,
-}
-/* No side effect */

package/src/SyncWrites.res

@@ -1,101 +0,0 @@
-// The writes one round of a synchronous handler has made. A round that
-// suspends is replayed from the top, so its writes are held here rather than
-// applied: the replay has to see the store exactly as the first round did, or a
-// read-modify-write lands once per round.
-
-type table = {
-  entityConfig: Internal.entityConfig,
-  scope: Internal.chainScope,
-  changes: dict<Change.t<Internal.entity>>,
-}
-
-// A handler runs on one chain, so an entity's scope is fixed for the whole
-// round and the entity name is enough to key its table.
-type t = dict<table>
-
-let make = (): t => Dict.make()
-
-let record = (writes: t, ~entityConfig: Internal.entityConfig, ~scope, change) => {
-  let table = switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
-  | Some(table) => table
-  | None =>
-    let table = {entityConfig, scope, changes: Dict.make()}
-    writes->Dict.set(entityConfig.name, table)
-    table
-  }
-  table.changes->Dict.set(change->Change.getEntityId->EntityId.toKey, change)
-}
-
-let changesOf = (writes: t, ~entityConfig: Internal.entityConfig) =>
-  switch writes->Utils.Dict.dangerouslyGetNonOption(entityConfig.name) {
-  | Some({changes}) => Some(changes)
-  | None => None
-  }
-
-// `Some(None)` is a delete this round made: the entity is known not to exist.
-let getById = (writes: t, ~entityConfig, ~entityId: string) =>
-  switch writes->changesOf(~entityConfig) {
-  | Some(changes) =>
-    changes
-    ->Utils.Dict.dangerouslyGetNonOption(entityId)
-    ->Option.map(InMemoryTable.Entity.mapChangeToEntity)
-  | None => None
-  }
-
-// What the store answered, as it reads once this round's writes land: a row
-// the round rewrote is re-tested against the filter, and one it created joins.
-let overlayFilter = (
-  writes: t,
-  entities: array<Internal.entity>,
-  ~entityConfig: Internal.entityConfig,
-  ~filter: EntityFilter.t,
-) =>
-  switch writes->changesOf(~entityConfig) {
-  | None => entities
-  | Some(changes) =>
-    let matches = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
-    let untouched =
-      entities->Array.filter(entity =>
-        !(changes->Dict.has(entity->InMemoryTable.Entity.getEntityIdUnsafe))
-      )
-    let written =
-      changes
-      ->Dict.valuesToArray
-      ->Array.filterMap(change =>
-        switch change->InMemoryTable.Entity.mapChangeToEntity {
-        | Some(entity) if matches(entity) => Some(entity)
-        | _ => None
-        }
-      )
-    untouched->Array.concat(written)
-  }
-
-// How a change lands in the in-memory store, whether written directly or
-// committed at the end of a round.
-let write = (indexerState, ~entityConfig: Internal.entityConfig, ~scope, change) => {
-  switch change {
-  | Change.Set({entityId}) =>
-    PreloadLookahead.onSet(
-      ~entityName=entityConfig.name,
-      ~scope,
-      ~entityId=entityId->EntityId.toKey,
-    )
-  | Delete(_) => ()
-  }
-  indexerState
-  ->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  ->InMemoryTable.Entity.set(
-    ~committedCheckpointId=indexerState->IndexerState.committedCheckpointIdFor(~scope),
-    change,
-  )
-}
-
-let forEachChange = (writes: t, fn) =>
-  writes->Utils.Dict.forEach(({entityConfig, scope, changes}) =>
-    changes->Utils.Dict.forEach(change => fn(~entityConfig, ~scope, change))
-  )
-
-let commit = (writes: t, ~indexerState) =>
-  writes->Utils.Dict.forEach(({entityConfig, scope, changes}) =>
-    changes->Utils.Dict.forEach(change => indexerState->write(~entityConfig, ~scope, change))
-  )

package/src/SyncWrites.res.mjs

@@ -1,98 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Utils from "./Utils.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
-import * as EntityFilter from "./db/EntityFilter.res.mjs";
-import * as IndexerState from "./IndexerState.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as InMemoryStore from "./InMemoryStore.res.mjs";
-import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as PreloadLookahead from "./PreloadLookahead.res.mjs";
-
-function make() {
-  return {};
-}
-
-function record(writes, entityConfig, scope, change) {
-  let table = writes[entityConfig.name];
-  let table$1;
-  if (table !== undefined) {
-    table$1 = table;
-  } else {
-    let table_changes = {};
-    let table$2 = {
-      entityConfig: entityConfig,
-      scope: scope,
-      changes: table_changes
-    };
-    writes[entityConfig.name] = table$2;
-    table$1 = table$2;
-  }
-  table$1.changes[EntityId.toKey(change.entityId)] = change;
-}
-
-function changesOf(writes, entityConfig) {
-  let match = writes[entityConfig.name];
-  if (match !== undefined) {
-    return match.changes;
-  }
-}
-
-function getById(writes, entityConfig, entityId) {
-  let changes = changesOf(writes, entityConfig);
-  if (changes !== undefined) {
-    return Stdlib_Option.map(changes[entityId], InMemoryTable.Entity.mapChangeToEntity);
-  }
-}
-
-function overlayFilter(writes, entities, entityConfig, filter) {
-  let changes = changesOf(writes, entityConfig);
-  if (changes === undefined) {
-    return entities;
-  }
-  let matches = EntityFilter.makeMatcher(filter, entityConfig.table);
-  let untouched = entities.filter(entity => !(InMemoryTable.Entity.getEntityIdUnsafe(entity) in changes));
-  let written = Stdlib_Array.filterMap(Object.values(changes), change => {
-    let entity = InMemoryTable.Entity.mapChangeToEntity(change);
-    if (entity !== undefined && matches(entity)) {
-      return entity;
-    }
-  });
-  return untouched.concat(written);
-}
-
-function write(indexerState, entityConfig, scope, change) {
-  if (change.type === "SET") {
-    PreloadLookahead.onSet(entityConfig.name, scope, EntityId.toKey(change.entityId));
-  }
-  InMemoryTable.Entity.set(InMemoryStore.getInMemTable(indexerState, entityConfig, scope), IndexerState.committedCheckpointIdFor(indexerState, scope), change);
-}
-
-function forEachChange(writes, fn) {
-  Utils.Dict.forEach(writes, param => {
-    let scope = param.scope;
-    let entityConfig = param.entityConfig;
-    Utils.Dict.forEach(param.changes, change => fn(entityConfig, scope, change));
-  });
-}
-
-function commit(writes, indexerState) {
-  Utils.Dict.forEach(writes, param => {
-    let scope = param.scope;
-    let entityConfig = param.entityConfig;
-    Utils.Dict.forEach(param.changes, change => write(indexerState, entityConfig, scope, change));
-  });
-}
-
-export {
-  make,
-  record,
-  changesOf,
-  getById,
-  overlayFilter,
-  write,
-  forEachChange,
-  commit,
-}
-/* Utils Not a pure module */

package/src/db/IndexDefinition.res

@@ -1,47 +0,0 @@
-// What the indexer wants an index to be: a table, its ordered key columns with
-// their directions, and an access method. The addon names it, matches it
-// against what PostgreSQL holds and builds it.
-
-type column = {
-  name: string,
-  direction: Table.indexFieldDirection,
-}
-
-type t = {
-  tableName: string,
-  columns: array<column>,
-  method: string,
-}
-
-let make = (~tableName, ~columns, ~method="btree") => {tableName, columns, method}
-
-let single = (~tableName, ~column) =>
-  make(~tableName, ~columns=[{name: column, direction: Table.Asc}])
-
-let fromIndexFields = (~tableName, ~indexFields: array<Table.compositeIndexField>) =>
-  make(
-    ~tableName,
-    ~columns=indexFields->Array.map(({fieldName, direction}) => {name: fieldName, direction}),
-  )
-
-let toInput = ({tableName, columns, method}: t): Core.pgIndexInput => {
-  tableName,
-  columns: columns->Array.map(({name, direction}): Core.pgIndexColumnInput => {
-    name,
-    direction: switch direction {
-    | Table.Asc => "Asc"
-    | Desc => "Desc"
-    },
-  }),
-  method,
-}
-
-let describe = (definition: t) =>
-  `${definition.tableName}(${definition.columns
-    ->Array.map(({name, direction}) =>
-      switch direction {
-      | Asc => name
-      | Desc => `${name} DESC`
-      }
-    )
-    ->Array.joinUnsafe(", ")}) using ${definition.method}`

package/src/db/IndexDefinition.res.mjs

@@ -1,60 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-function make(tableName, columns, methodOpt) {
-  let method = methodOpt !== undefined ? methodOpt : "btree";
-  return {
-    tableName: tableName,
-    columns: columns,
-    method: method
-  };
-}
-
-function single(tableName, column) {
-  return make(tableName, [{
-      name: column,
-      direction: "Asc"
-    }], undefined);
-}
-
-function fromIndexFields(tableName, indexFields) {
-  return make(tableName, indexFields.map(param => ({
-    name: param.fieldName,
-    direction: param.direction
-  })), undefined);
-}
-
-function toInput(param) {
-  return {
-    tableName: param.tableName,
-    columns: param.columns.map(param => {
-      let tmp;
-      tmp = param.direction === "Asc" ? "Asc" : "Desc";
-      return {
-        name: param.name,
-        direction: tmp
-      };
-    }),
-    method: param.method
-  };
-}
-
-function describe(definition) {
-  return definition.tableName + `(` + definition.columns.map(param => {
-    let name = param.name;
-    if (param.direction === "Asc") {
-      return name;
-    } else {
-      return name + ` DESC`;
-    }
-  }).join(", ") + `) using ` + definition.method;
-}
-
-export {
-  make,
-  single,
-  fromIndexFields,
-  toInput,
-  describe,
-}
-/* No side effect */

package/src/sources/CallSource.res

@@ -1,274 +0,0 @@
-// Subgraph mode only. A subgraph's call handlers run on calls, which a log
-// source never sees, so each source of a chain is wrapped: it fetches the logs
-// of a query as before, and the calls of the same block range from a trace
-// backend (`subgraph/calls-source.ts`). A call comes back as the event item it
-// travels as for the rest of envio — partitioning, ordering, the register
-// pass and rollback never tell it from a log.
-
-type callRegistration = {
-  index: int,
-  contractName: string,
-  eventName: string,
-  selector: Nullable.t<string>,
-  rank: int,
-  isWildcard: bool,
-  startBlock: Nullable.t<int>,
-}
-
-type request = {
-  chainId: ChainId.t,
-  fromBlock: int,
-  toBlock: int,
-  registrations: array<callRegistration>,
-  addresses: dict<array<string>>,
-  rpcUrls: array<string>,
-}
-
-type callItem = {
-  registrationIndex: int,
-  blockNumber: int,
-  transactionIndex: int,
-  traceAddress: array<int>,
-  payload: Internal.eventPayload,
-}
-
-type response = {
-  items: array<callItem>,
-  latestFetchedBlockNumber: int,
-  blocks: array<BlockStore.inputBlock>,
-  knownHeight: Nullable.t<int>,
-}
-
-type installed = {
-  fetchCalls: request => promise<response>,
-  rpcUrls: array<string>,
-}
-
-let installed: ref<option<installed>> = ref(None)
-
-let install = (~fetchCalls, ~rpcUrls) => {
-  installed := Some({fetchCalls, rpcUrls})
-}
-
-// The block range one call query covers when the partition's own is open-ended.
-let openEndedSpan = 1_000_000
-
-let callRankOf = (registration: Internal.onEventRegistration) =>
-  Internal.callRankOfEventName(registration.eventConfig.name)
-
-// `__envio_call_<8 hex digits>_<function>`
-let selectorOf = (registration: Internal.onEventRegistration) =>
-  switch registration->callRankOf {
-  | Some(1) =>
-    Nullable.Value(
-      "0x" ++ registration.eventConfig.name->String.slice(~start=13, ~end=21)->String.toLowerCase,
-    )
-  | _ => Nullable.null
-  }
-
-let wrap = (
-  source: Source.t,
-  ~addressStore: AddressStore.t,
-  ~ecosystem: Ecosystem.name,
-  installed: installed,
-): Source.t => {
-  ...source,
-  getItemsOrThrow: async (
-    ~fromBlock,
-    ~toBlock,
-    ~addressSet,
-    ~reorgableFrom,
-    ~knownHeight,
-    ~partitionId,
-    ~selection: FetchState.selection,
-    ~itemsTarget,
-    ~retry,
-    ~logger,
-  ) => {
-    let callRegistrations =
-      selection.onEventRegistrations->Array.filter(registration =>
-        registration->callRankOf->Option.isSome
-      )
-    if callRegistrations->Utils.Array.isEmpty {
-      await source.getItemsOrThrow(
-        ~fromBlock,
-        ~toBlock,
-        ~addressSet,
-        ~reorgableFrom,
-        ~knownHeight,
-        ~partitionId,
-        ~selection,
-        ~itemsTarget,
-        ~retry,
-        ~logger,
-      )
-    } else {
-      let logRegistrations =
-        selection.onEventRegistrations->Array.filter(registration =>
-          registration->callRankOf->Option.isNone
-        )
-      let logs = if (
-        logRegistrations->Utils.Array.isEmpty && selection.onBlockRegistrations->Utils.Array.isEmpty
-      ) {
-        None
-      } else {
-        Some(
-          await source.getItemsOrThrow(
-            ~fromBlock,
-            ~toBlock,
-            ~addressSet,
-            ~reorgableFrom,
-            ~knownHeight,
-            ~partitionId,
-            ~selection={...selection, onEventRegistrations: logRegistrations},
-            ~itemsTarget,
-            ~retry,
-            ~logger,
-          ),
-        )
-      }
-
-      // Calls are asked for only as far as the logs were: a source may stop a
-      // page short, and the two have to agree on where the answer ends.
-      let rangeEnd = switch (logs, toBlock) {
-      | (Some(logs), _) => logs.latestFetchedBlockNumber
-      | (None, Some(toBlock)) => toBlock
-      | (None, None) => Math.Int.min(knownHeight, fromBlock + openEndedSpan)
-      }
-
-      let clientFiltered = contractName =>
-        switch selection.clientFilteredContracts {
-        | Some(contractNames) => contractNames->Array.includes(contractName)
-        | None => false
-        }
-      let addresses = Dict.make()
-      callRegistrations->Array.forEach(registration => {
-        let contractName = registration.eventConfig.contractName
-        if !registration.isWildcard && addresses->Dict.get(contractName)->Option.isNone {
-          addresses->Dict.set(
-            contractName,
-            clientFiltered(contractName)
-              ? addressStore->AddressStore.contractAddresses(contractName, ~shouldChecksum=false)
-              : addressSet->AddressSet.addressesOf(contractName),
-          )
-        }
-      })
-
-      let startedAt = Performance.now()
-      let response = try await installed.fetchCalls({
-        chainId: source.chainId,
-        fromBlock,
-        toBlock: rangeEnd,
-        registrations: callRegistrations->Array.map(registration => {
-          index: registration.index,
-          contractName: registration.eventConfig.contractName,
-          eventName: registration.eventConfig.name,
-          selector: registration->selectorOf,
-          rank: registration->callRankOf->Option.getOr(1),
-          isWildcard: registration.isWildcard,
-          startBlock: registration.startBlock->Nullable.fromOption,
-        }),
-        addresses: addresses->(Utils.magic: dict<array<Address.t>> => dict<array<string>>),
-        rpcUrls: installed.rpcUrls,
-      }) catch {
-      | exn =>
-        throw(
-          Source.GetItemsError(
-            Source.FailedGettingItems({
-              exn,
-              attemptedToBlock: rangeEnd,
-              retry: WithBackoff({
-                message: `Failed reading the calls of blocks ${fromBlock->Int.toString} to ${rangeEnd->Int.toString}. Attempt a retry.`,
-                backoffMillis: switch retry {
-                | 0 => 500
-                | _ => 1000 * retry
-                },
-              }),
-              requestStats: [],
-            }),
-          ),
-        )
-      }
-      let callSeconds = startedAt->Performance.secondsSince
-
-      let registrationByIndex = Dict.make()
-      callRegistrations->Array.forEach(registration =>
-        registrationByIndex->Dict.set(registration.index->Int.toString, registration)
-      )
-      let latest = response.latestFetchedBlockNumber
-      let callItems = response.items->Array.filterMap(callItem => {
-        let registration =
-          registrationByIndex->Dict.getUnsafe(callItem.registrationIndex->Int.toString)
-        let contractName = registration.eventConfig.contractName
-        // The partition's own slice of the contract's addresses, as a log's
-        // router applies it; a client-filtered contract answers to the store.
-        let ownsCall =
-          registration.isWildcard || {
-            let address = callItem.payload->Internal.getPayloadSrcAddress
-            if clientFiltered(contractName) {
-              addressStore->AddressStore.isIndexedAt(address, contractName, callItem.blockNumber)
-            } else {
-              addressSet->AddressSet.containsAt(address, contractName, callItem.blockNumber)
-            }
-          }
-        if callItem.blockNumber <= latest && ownsCall {
-          let item = Internal.Event({
-            onEventRegistration: registration,
-            chainId: source.chainId,
-            blockNumber: callItem.blockNumber,
-            logIndex: 0,
-            orderPath: callItem.traceAddress,
-            transactionIndex: callItem.transactionIndex,
-            payload: callItem.payload,
-          })
-          item->Internal.markItemCall(~rank=registration->callRankOf->Option.getOr(1))
-          Some(item)
-        } else {
-          None
-        }
-      })
-
-      let callBlocks = BlockStore.fromJs(response.blocks, ~ecosystem)
-      let callRequestStat = {Source.method: "getCalls", seconds: callSeconds}
-      switch logs {
-      | Some(logs) =>
-        logs.blockStore->BlockStore.appendPage(callBlocks)
-        {
-          ...logs,
-          parsedQueueItems: Array.concat(
-            logs.parsedQueueItems->Array.filter(item =>
-              item->Internal.getItemBlockNumber <= latest
-            ),
-            callItems,
-          ),
-          latestFetchedBlockNumber: Math.Int.min(logs.latestFetchedBlockNumber, latest),
-          requestStats: Array.concat(logs.requestStats, [callRequestStat]),
-        }
-      | None => {
-          Source.knownHeight: response.knownHeight->Nullable.getOr(knownHeight),
-          parsedQueueItems: callItems,
-          transactionStore: None,
-          blockStore: callBlocks,
-          latestFetchedBlockNumber: latest,
-          stats: {totalTimeElapsed: callSeconds},
-          requestStats: [callRequestStat],
-        }
-      }
-    }
-  },
-}
-
-// Wraps every source of a chain when its registrations hold a call trigger
-// and the subgraph runtime has installed the backend that reads them.
-let wrapSources = (
-  sources: array<Source.t>,
-  ~onEventRegistrations: array<Internal.onEventRegistration>,
-  ~addressStore,
-  ~ecosystem,
-) =>
-  switch installed.contents {
-  | Some(installed)
-    if onEventRegistrations->Array.some(registration => registration->callRankOf->Option.isSome) =>
-    sources->Array.map(source => source->wrap(~addressStore, ~ecosystem, installed))
-  | _ => sources
-  }