envio 3.7.0 → 3.8.0

package/src/Internal.res.mjs

@@ -88,20 +88,10 @@ let allSvmTransactionFields = [
   "accountKeys",
   "recentBlockhash",
   "version",
-  "tokenBalances",
-  "allSignatures"
+  "allSignatures",
+  "accountActivities"
 ];
 
-let svmTransactionFieldSchema = S$RescriptSchema.$$enum(allSvmTransactionFields);
-
-let allSvmBlockFields = [
-  "height",
-  "parentSlot",
-  "parentHash"
-];
-
-let svmBlockFieldSchema = S$RescriptSchema.$$enum(allSvmBlockFields);
-
 let evmNullableBlockFields = new Set([
   "nonce",
   "difficulty",
@@ -141,10 +131,16 @@ let evmNullableTransactionFields = new Set([
   "type"
 ]);
 
-function makeFieldSelection(blockFields, transactionFields, blockMaskFn, transactionMaskFn) {
+function makeFieldSelection(blockFields, transactionFields, instructionFieldsOpt, accountActivityFieldsOpt, logFieldsOpt, blockMaskFn, transactionMaskFn) {
+  let instructionFields = instructionFieldsOpt !== undefined ? Primitive_option.valFromOption(instructionFieldsOpt) : new Set();
+  let accountActivityFields = accountActivityFieldsOpt !== undefined ? Primitive_option.valFromOption(accountActivityFieldsOpt) : new Set();
+  let logFields = logFieldsOpt !== undefined ? Primitive_option.valFromOption(logFieldsOpt) : new Set();
   return {
     blockFields: blockFields,
     transactionFields: transactionFields,
+    instructionFields: instructionFields,
+    accountActivityFields: accountActivityFields,
+    logFields: logFields,
     blockMask: blockMaskFn(blockFields),
     transactionMask: transactionMaskFn(transactionFields)
   };
@@ -162,6 +158,9 @@ function unionFieldSelection(a, b) {
   return {
     blockFields: unionFields(a.blockFields, b.blockFields),
     transactionFields: unionFields(a.transactionFields, b.transactionFields),
+    instructionFields: unionFields(a.instructionFields, b.instructionFields),
+    accountActivityFields: unionFields(a.accountActivityFields, b.accountActivityFields),
+    logFields: unionFields(a.logFields, b.logFields),
     blockMask: FieldMask.orMask(a.blockMask, b.blockMask),
     transactionMask: FieldMask.orMask(a.transactionMask, b.transactionMask)
   };
@@ -329,9 +328,6 @@ export {
   allEvmTransactionFields,
   evmTransactionFieldSchema,
   allSvmTransactionFields,
-  svmTransactionFieldSchema,
-  allSvmBlockFields,
-  svmBlockFieldSchema,
   evmNullableBlockFields,
   evmNullableTransactionFields,
   makeFieldSelection,

package/src/Main.res

@@ -239,7 +239,7 @@ let getGlobalIndexer = (): 'indexer => {
           "event": unknown,
           "wildcard": option<bool>,
           "where": option<JSON.t>,
-          "fields": option<Internal.evmFieldsSelection>,
+          "fields": option<unknown>,
         }
       )
     // Detect format: if "contract" is a string, it's the TS format
@@ -295,7 +295,7 @@ let getGlobalIndexer = (): 'indexer => {
           "program": unknown,
           "instruction": unknown,
           "where": option<JSON.t>,
-          "fields": option<Internal.evmFieldsSelection>,
+          "fields": option<unknown>,
         }
       )
     let (programName, instructionName) = if typeof(raw["program"]) === #string {
@@ -308,9 +308,6 @@ let getGlobalIndexer = (): 'indexer => {
       (inst["contract"], inst["_0"])
     }
     let where = raw["where"]
-    // SVM takes its selection from the config, so `fields` is carried through
-    // only to be rejected by the registration — dropping it here would leave a
-    // plain-JS caller with a silently ignored option.
     let fields = raw["fields"]
     let eventOptions: option<Internal.eventOptions<_>> = switch (where, fields) {
     | (None, None) => None

package/src/MemoryStorage.res

@@ -232,11 +232,24 @@ let toInitialState = (state: t, ~cleanRun): Persistence.initialState => {
 let handleLoad = (state: t, ~tableName: string, ~filter: EntityFilter.t): array<
   Internal.entity,
 > => {
-  // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
-  // here too. Nothing persists those, so there's nothing to return — an empty
-  // result makes the effect recompute instead of crashing on a missing config.
+  // Effect caches (`envio_effect_<name>`) are loaded through the same call, and
+  // they have no entity config — they're served from the cache `writeBatch`
+  // filled, so a resumed indexer reuses cached outputs instead of recomputing
+  // them the way Postgres would.
   switch state.entityConfigs->Dict.get(tableName) {
-  | None => []
+  | None =>
+    switch state.effectCache->Dict.get(tableName) {
+    | None => []
+    | Some(cacheDict) =>
+      cacheDict
+      ->Dict.valuesToArray
+      ->Array.filter(item =>
+        filter->EntityFilter.matches(
+          ~entity=item->(Utils.magic: Internal.effectCacheItem => dict<EntityFilter.FieldValue.t>),
+        )
+      )
+      ->(Utils.magic: array<Internal.effectCacheItem> => array<Internal.entity>)
+    }
   | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
     let matched =
@@ -320,6 +333,17 @@ let writeBatch = (
   | None => ()
   }
 
+  // The rollback diff restates what the reverted state already is, so it is not
+  // a change history should record — and an id it touches needs no backfill
+  // either, because the diff already carries its reverted value. Postgres draws
+  // the same line, keyed on the diff's checkpoint id.
+  let diffCheckpointId = rollback->Option.map(({diffCheckpointId}) => diffCheckpointId)
+  let isDiff = (change: Change.t<Internal.entity>) =>
+    switch diffCheckpointId {
+    | Some(diffCheckpointId) => change->Change.getCheckpointId === diffCheckpointId
+    | None => false
+    }
+
   updatedEntities->Array.forEach(({entityConfig, scope, changes}: Persistence.updatedEntity) => {
     let entityDict = state->getEntityDict(~name=entityConfig.name)
     let historyRows = state->getHistory(~name=entityConfig.name)
@@ -327,9 +351,17 @@ let writeBatch = (
     // onto the stored entity the same way the Postgres write path does.
     let chainIdField = entityConfig.table->Table.getChainIdField
 
+    let idsWithDiff = Utils.Set.make()
+    changes->Array.forEach(change =>
+      if isDiff(change) {
+        idsWithDiff->Utils.Set.add(change->Change.getEntityId->EntityId.toKey)->ignore
+      }
+    )
+
     changes->Array.forEach(change => {
       let entityId = change->Change.getEntityId
-      if shouldSaveHistory {
+      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change)
+      if shouldSaveHistory && !(idsWithDiff->Utils.Set.has(entityId->EntityId.toKey)) {
         state->backfillHistory(~entityConfig, ~scope, ~entityId, ~rows=historyRows)
       }
       switch change {
@@ -340,7 +372,7 @@ let writeBatch = (
         | _ => entity
         }
         entityDict->Dict.set(rowKey(~scope, ~entityId), storedEntity)
-        if shouldSaveHistory {
+        if shouldSaveChangeHistory {
           historyRows
           ->Array.push({
             entityId,
@@ -353,7 +385,7 @@ let writeBatch = (
         }
       | Delete({checkpointId}) =>
         entityDict->Utils.Dict.deleteInPlace(rowKey(~scope, ~entityId))
-        if shouldSaveHistory {
+        if shouldSaveChangeHistory {
           historyRows
           ->Array.push({
             entityId,
@@ -472,7 +504,7 @@ let getRollbackData = (
     | Some({action: DELETE, entityId, scope}) =>
       removals->Array.push({Persistence.entityId, scope})->ignore
     | Some({action: SET, entity: Some(entity)}) =>
-      restored->Array.push(entity->(Utils.magic: Internal.entity => unknown))->ignore
+      restored->Array.push(entity)->ignore
     | Some({action: SET, entity: None}) => ()
     }
   })

package/src/MemoryStorage.res.mjs

@@ -187,20 +187,25 @@ function toInitialState(state, cleanRun) {
 
 function handleLoad(state, tableName, filter) {
   let entityConfig = state.entityConfigs[tableName];
-  if (entityConfig === undefined) {
-    return [];
+  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 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;
-    });
+  let cacheDict = state.effectCache[tableName];
+  if (cacheDict !== undefined) {
+    return Object.values(cacheDict).filter(item => EntityFilter.matches(filter, item));
   } else {
-    return matched;
+    return [];
   }
 }
 
@@ -234,15 +239,32 @@ function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedE
   if (rollback !== undefined) {
     applyRollback(state, rollback.targetCheckpointId);
   }
+  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);
-    param.changes.forEach(change => {
+    let idsWithDiff = new Set();
+    changes.forEach(change => {
+      if (isDiff(change)) {
+        idsWithDiff.add(EntityId.toKey(change.entityId));
+        return;
+      }
+    });
+    changes.forEach(change => {
       let entityId = change.entityId;
-      if (shouldSaveHistory) {
+      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change);
+      if (shouldSaveHistory && !idsWithDiff.has(EntityId.toKey(entityId))) {
         backfillHistory(state, entityConfig, scope, entityId, historyRows);
       }
       if (change.type === "SET") {
@@ -250,7 +272,7 @@ function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedE
         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 (shouldSaveHistory) {
+        if (shouldSaveChangeHistory) {
           historyRows.push({
             entityId: entityId,
             scope: scope,
@@ -264,7 +286,7 @@ function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedE
         }
       }
       Utils.Dict.deleteInPlace(entityDict, rowKey(scope, entityId));
-      if (shouldSaveHistory) {
+      if (shouldSaveChangeHistory) {
         historyRows.push({
           entityId: entityId,
           scope: scope,

package/src/Persistence.res

@@ -147,11 +147,13 @@ type storage = {
       "new_progress_block_number": int,
     }>,
   >,
-  // Get rollback data for entity
+  // Rollback data for an entity, as decoded entities rather than storage rows:
+  // only the storage knows how it encoded them, so each one decodes its own
+  // before handing them back.
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => promise<(array<rollbackRemoval>, array<unknown>)>,
+  ) => promise<(array<rollbackRemoval>, array<Internal.entity>)>,
   // Write batch to storage
   writeBatch: (
     ~batch: Batch.t,

package/src/PgStorage.res

@@ -2308,7 +2308,12 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::${addrChai
       }
     })
 
-    (removals, restoredEntitiesResult)
+    (
+      removals,
+      restoredEntitiesResult
+      ->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
+      ->(Utils.magic: array<unknown> => array<Internal.entity>),
+    )
   }
 
   let writeBatchMethod = async (

package/src/PgStorage.res.mjs

@@ -1464,7 +1464,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
     });
     return [
       removals,
-      restoredEntitiesResult
+      S$RescriptSchema.parseOrThrow(restoredEntitiesResult, Table.pgRowsSchema(entityConfig.table))
     ];
   };
   let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData, onWrite) => {

package/src/SimulateItems.res

@@ -174,6 +174,8 @@ type rawSimulateItem
 
 @get external getContract: rawSimulateItem => option<string> = "contract"
 @get external getEvent: rawSimulateItem => option<string> = "event"
+@get external getProgram: rawSimulateItem => option<string> = "program"
+@get external getInstruction: rawSimulateItem => option<string> = "instruction"
 
 let findEventConfig = (~config: Config.t, ~contractName: string, ~eventName: string) => {
   let found = ref(None)
@@ -240,18 +242,71 @@ let deriveSrcAddress = (
   }
 }
 
+type parseResult = {
+  items: array<Internal.item>,
+  transactionStore: option<TransactionStore.t>,
+  blockStore: option<BlockStore.t>,
+}
+
+type svmSimActivity = {
+  address: string,
+  transactionAccountIndex?: int,
+  isSigner?: bool,
+  isWritable?: bool,
+  lamports?: {pre?: bigint, post?: bigint},
+  token?: {
+    mint?: string,
+    owner?: string,
+    decimals?: int,
+    preAmount?: bigint,
+    postAmount?: bigint,
+  },
+}
+
+type svmSimTransaction = {
+  transactionIndex?: int,
+  signature?: string,
+  allSignatures?: array<string>,
+  feePayer?: string,
+  success?: bool,
+  err?: string,
+  fee?: bigint,
+  computeUnitsConsumed?: bigint,
+  accountKeys?: array<string>,
+  recentBlockhash?: string,
+  version?: string,
+  accountActivities?: array<svmSimActivity>,
+}
+
+let liveRegistrationsFor = (
+  ~config: Config.t,
+  ~chainId: ChainId.t,
+  ~eventConfig: Internal.eventConfig,
+) =>
+  HandlerRegister.getSimulateOnEventRegistrations(
+    ~config,
+    ~chainId,
+    ~eventConfig,
+  )->Array.filter(reg =>
+    (reg.handler->Option.isSome || reg.contractRegister->Option.isSome) &&
+      !HandlerRegister.isDroppedByWhere(~config, reg)
+  )
+
 let parse = (
   ~simulateItems: array<JSON.t>,
   ~config: Config.t,
   ~chainConfig: Config.chain,
   ~onEventRegistrations: array<Internal.onEventRegistration>,
-): array<Internal.item> => {
+): parseResult => {
   let chainId = chainConfig.id
   let startBlock = chainConfig.startBlock
   let currentBlock = ref(startBlock)
   let currentLogIndex = ref(0)
 
   let items = []
+  let svmTxs: array<TransactionStore.svmTxInput> = []
+  let svmActivities: array<TransactionStore.svmActivityInput> = []
+  let svmBlocks: array<BlockStore.inputBlock> = []
   // Coordinate "block:logIndex" -> the index of the first item that claimed it,
   // used to reject two items resolving to the same (block, logIndex).
   let seenCoordinates = Dict.make()
@@ -259,8 +314,189 @@ let parse = (
   simulateItems->Array.forEachWithIndex((rawJson, itemIndex) => {
     let raw = rawJson->(Utils.magic: JSON.t => rawSimulateItem)
 
-    switch (raw->getContract, raw->getEvent) {
-    | (Some(contractName), Some(eventName)) =>
+    switch (config.ecosystem.name, raw->getProgram, raw->getInstruction) {
+    | (Svm, Some(programName), Some(instructionName)) =>
+      let eventConfig = switch findEventConfig(
+        ~config,
+        ~contractName=programName,
+        ~eventName=instructionName,
+      ) {
+      | Some(ec) => ec
+      | None =>
+        JsError.throwWithMessage(
+          `simulate: Instruction "${instructionName}" not found on program "${programName}". ` ++ `Check that the program and instruction names match your config.yaml.`,
+        )
+      }
+      let svmEventConfig =
+        eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+      let item = rawJson->(Utils.magic: JSON.t => Envio.svmSimulateItem)
+      let rawItem = rawJson->(Utils.magic: JSON.t => {..})
+      let blockJson: option<JSON.t> =
+        rawItem["block"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
+      let slot = switch item.slot {
+      | Some(s) => s
+      | None =>
+        switch blockJson {
+        | Some(bj) =>
+          switch (bj->(Utils.magic: JSON.t => dict<JSON.t>))->Dict.get("slot") {
+          | Some(v) =>
+            v->(Utils.magic: JSON.t => Nullable.t<int>)->Nullable.toOption->Option.getOr(
+              currentBlock.contents,
+            )
+          | None => currentBlock.contents
+          }
+        | None => currentBlock.contents
+        }
+      }
+      currentBlock := slot
+      let transaction = switch item.transaction {
+      | Some(tx) => tx->(Utils.magic: unknown => svmSimTransaction)
+      | None => {}
+      }
+      let transactionIndex = transaction.transactionIndex->Option.getOr(0)
+      let path = item.path->Option.getOr([0])
+      let programId =
+        item.programId->Option.getOr(svmEventConfig.programId->SvmTypes.Pubkey.toString)
+      let accountArguments = switch item.accountArguments {
+      | Some(args) => args
+      | None =>
+        switch item.accounts {
+        | Some(named) =>
+          svmEventConfig.accounts->Array.map(name =>
+            switch named->Dict.get(name) {
+            | Some({address}) => address
+            | None => ""
+            }
+          )
+        | None => []
+        }
+      }
+      let data = item.data->Option.getOr(svmEventConfig.discriminator->Option.getOr("0x"))
+      let decoded = item.args->Option.map(args => (
+        {
+          SvmHyperSyncClient.ResponseTypes.name: instructionName,
+          argsJson: args->JSON.stringify,
+          accountsJson: "{}",
+          extraAccounts: [],
+        }: SvmHyperSyncClient.ResponseTypes.decodedInstruction
+      ))
+      let logs = item.logs->Option.map(logs =>
+        logs->Array.map((log): SvmHyperSyncClient.EventItems.log => {
+          kind: ?log.kind,
+          message: ?log.message,
+        })
+      )
+
+      let liveRegistrations = liveRegistrationsFor(~config, ~chainId, ~eventConfig)
+      if liveRegistrations->Utils.Array.isEmpty {
+        JsError.throwWithMessage(
+          `simulate: no handler runs for instruction "${instructionName}" on program "${programName}". Register a handler with indexer.onInstruction before simulating it.`,
+        )
+      }
+
+      svmTxs
+      ->Array.push({
+        slot,
+        transactionIndex,
+        signature: ?transaction.signature,
+        allSignatures: ?transaction.allSignatures,
+        feePayer: ?transaction.feePayer,
+        success: ?transaction.success,
+        err: ?transaction.err,
+        fee: ?transaction.fee,
+        computeUnitsConsumed: ?transaction.computeUnitsConsumed,
+        accountKeys: ?transaction.accountKeys,
+        recentBlockhash: ?transaction.recentBlockhash,
+        version: ?transaction.version,
+      })
+      ->ignore
+      switch transaction.accountActivities {
+      | Some(rows) =>
+        rows->Array.forEach(activity =>
+          svmActivities
+          ->Array.push({
+            TransactionStore.slot,
+            transactionIndex,
+            account: activity.address,
+            accountIndex: ?activity.transactionAccountIndex,
+            isSigner: ?activity.isSigner,
+            isWritable: ?activity.isWritable,
+            preBalance: ?activity.lamports->Option.flatMap(l => l.pre),
+            postBalance: ?activity.lamports->Option.flatMap(l => l.post),
+            mint: ?activity.token->Option.flatMap(t => t.mint),
+            owner: ?activity.token->Option.flatMap(t => t.owner),
+            decimals: ?activity.token->Option.flatMap(t => t.decimals),
+            preAmount: ?activity.token->Option.flatMap(t => t.preAmount),
+            postAmount: ?activity.token->Option.flatMap(t => t.postAmount),
+          })
+          ->ignore
+        )
+      | None => ()
+      }
+      let blockTime = switch item.block {
+      | Some(block) => block.time
+      | None => None
+      }
+      let blockHash = switch item.block {
+      | Some(block) => block.hash
+      | None => None
+      }
+      svmBlocks
+      ->Array.push({
+        blockNumber: slot,
+        ?blockHash,
+        blockTimestamp: ?blockTime,
+      })
+      ->ignore
+
+      liveRegistrations->Array.forEach(reg => {
+        let onEventRegistrationIndex = onEventRegistrations->Array.length
+        let onEventRegistration = {...reg, index: onEventRegistrationIndex}
+        onEventRegistrations->Array.push(onEventRegistration)->ignore
+        let payload = SvmHyperSyncSource.toSvmInstruction(
+          {
+            onEventRegistrationIndex,
+            slot,
+            transactionIndex,
+            path,
+            programId,
+            accounts: accountArguments,
+            data,
+            isInner: item.isInner->Option.getOr(false),
+            ?decoded,
+            ?logs,
+          },
+          ~programName,
+          ~instructionName,
+          ~eventConfig=svmEventConfig,
+          ~fieldSelection=onEventRegistration.fieldSelection,
+        )
+        let payloadDict = payload->(Utils.magic: Envio.svmInstruction => dict<unknown>)
+        payloadDict->Dict.set("srcAddress", programId->(Utils.magic: string => unknown))
+        items
+        ->Array.push(
+          Internal.Event({
+            onEventRegistration,
+            chainId,
+            blockNumber: slot,
+            logIndex: transactionIndex,
+            orderPath: path,
+            transactionIndex,
+            payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),
+          }),
+        )
+        ->ignore
+      })
+
+    | (Svm, _, _) =>
+      JsError.throwWithMessage(`simulate: Invalid item. Each item must have "program" and "instruction" fields.`)
+
+    | (_, _, _) =>
+      let (contractName, eventName) = switch (raw->getContract, raw->getEvent) {
+      | (Some(c), Some(e)) => (c, e)
+      | _ =>
+        JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`)
+      }
       // Event simulate item
       let eventConfig = switch findEventConfig(~config, ~contractName, ~eventName) {
       | Some(ec) => ec
@@ -399,13 +635,21 @@ let parse = (
         )
         ->ignore
       })
-
-    | _ =>
-      JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`)
     }
   })
 
-  items
+  switch config.ecosystem.name {
+  | Svm => {
+      items,
+      transactionStore: Some(TransactionStore.fromSvmJs(svmTxs, svmActivities)),
+      blockStore: Some(BlockStore.fromJs(svmBlocks, ~ecosystem=Svm, ~shouldChecksum=false)),
+    }
+  | _ => {
+      items,
+      transactionStore: None,
+      blockStore: None,
+    }
+  }
 }
 
 // Apply simulate source config from processConfig JSON to a Config.t
@@ -444,13 +688,21 @@ let patchConfig = (
           // Parse with the process's startBlock so items default into the range
           // the source will be queried over; the source now filters by range.
           let chainConfig = {...chainConfig, startBlock, endBlock}
-          let items = parse(
+          let {items, transactionStore, blockStore} = parse(
             ~simulateItems,
             ~config,
             ~chainConfig,
             ~onEventRegistrations=chainRegistrations.onEventRegistrations,
           )
-          {...chainConfig, sourceConfig: Config.SimulateSourceConfig({items, endBlock})}
+          {
+            ...chainConfig,
+            sourceConfig: Config.SimulateSourceConfig({
+              items,
+              endBlock,
+              ?transactionStore,
+              ?blockStore,
+            }),
+          }
         | None => chainConfig
         }
       | None => chainConfig