envio 3.9.0 → 3.10.0

package/src/Rollback.res

@@ -127,86 +127,105 @@ and executeRollback = async (
     }
   }
 
-  let eventsProcessedDiffByChain = Dict.make()
-  let newProgressBlockNumberPerChain = Dict.make()
+  // The diff computed here replaces a pending one rather than merging with it,
+  // so its deletes have to cover everything that one would have deleted. The
+  // flush above leaves a diff pending only when no batch has come along to
+  // carry it.
+  let floors = {
+    let next = if state->IndexerState.config->Config.isIsolatedMultichain {
+      RollbackFloors.isolated(
+        ~chainId=reorgChain,
+        ~floorCheckpointId=rollbackTargetCheckpointId,
+        ~forkBlockNumber=rollbackTargetBlockNumber,
+      )
+    } else {
+      RollbackFloors.global(
+        ~floorCheckpointId=rollbackTargetCheckpointId,
+        ~reorgChainId=reorgChain,
+        ~forkBlockNumber=rollbackTargetBlockNumber,
+      )
+    }
+    switch state->IndexerState.pendingRollback {
+    | None => next
+    | Some({floors: pending}) => RollbackFloors.merge(pending, next)
+    }
+  }
+
+  let progressDiffByChain: dict<ChainState.progressDiff> = Dict.make()
   let rollbackedProcessedEvents = ref(0.)
 
   {
     let rollbackProgressDiff = await (
       state->IndexerState.persistence
-    ).storage.getRollbackProgressDiff(~rollbackTargetCheckpointId)
+    ).storage.getRollbackProgressDiff(~floors)
     for idx in 0 to rollbackProgressDiff->Array.length - 1 {
       let diff = rollbackProgressDiff->Array.getUnsafe(idx)
-      eventsProcessedDiffByChain->ChainId.Dict.set(
-        diff["chain_id"],
+      let chainId = diff["chain_id"]
+      let eventsProcessed = Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
+      rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessed
+      progressDiffByChain->ChainId.Dict.set(
+        chainId,
         {
-          let eventsProcessedDiff =
-            Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
-          rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessedDiff
-          eventsProcessedDiff
-        },
-      )
-      newProgressBlockNumberPerChain->ChainId.Dict.set(
-        diff["chain_id"],
-        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChain {
-          Pervasives.min(diff["new_progress_block_number"], rollbackTargetBlockNumber)
-        } else {
-          diff["new_progress_block_number"]
+          blockNumber: diff["new_progress_block_number"],
+          eventsProcessed,
         },
       )
     }
   }
 
-  let rolledBackChains = []
+  // Where the rollback leaves each chain it moved, written with the diff: the
+  // batch that carries it may belong to a chain the rollback never touched.
+  let rolledBackChains: array<InternalTable.Chains.progressedChain> = []
   let rolledBackAddresses = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
     let fromBlock = cs->ChainState.committedProgressBlockNumber
-    let killedAddresses =
-      cs->ChainState.rollback(
-        ~newProgressBlockNumber=newProgressBlockNumberPerChain->ChainId.Dict.dangerouslyGetNonOption(
-          chainId,
-        ),
-        ~eventsProcessedDiff=eventsProcessedDiffByChain->ChainId.Dict.dangerouslyGetNonOption(
-          chainId,
-        ),
-        ~rollbackTargetBlockNumber,
-        ~isReorgChain=chainId === reorgChain,
-      )
+    let progressDiff = progressDiffByChain->ChainId.Dict.dangerouslyGetNonOption(chainId)
+    let killedAddresses = cs->ChainState.rollback(
+      ~rolledBackTo=switch (progressDiff, floors->RollbackFloors.forkBlockNumber(chainId)) {
+      | (Some(progressDiff), forkBlockNumber) =>
+        RecomputedProgress({
+          ...progressDiff,
+          blockNumber: forkBlockNumber->Option.mapOr(progressDiff.blockNumber, forkBlockNumber =>
+            Pervasives.min(progressDiff.blockNumber, forkBlockNumber)
+          ),
+        })
+      // Nothing of this chain's is above its floor, so there are no checkpoints
+      // to recompute from.
+      | (None, Some(forkBlockNumber)) => ForkBlock(forkBlockNumber)
+      | (None, None) => Untouched
+      },
+    )
     rolledBackAddresses->Array.pushMany(killedAddresses)->ignore
     let toBlock = cs->ChainState.committedProgressBlockNumber
     if fromBlock !== toBlock {
       rolledBackChains
       ->Array.push({
+        chainId,
+        progressBlockNumber: toBlock,
+        sourceBlockNumber: cs->ChainState.knownHeight,
+        totalEventsProcessed: cs->ChainState.numEventsProcessed,
+      })
+      ->ignore
+      logger->Logging.childInfo({
+        "msg": "Rollbacked",
         "chainId": chainId,
         "fromBlock": fromBlock,
         "toBlock": toBlock,
-        "rollbackedEvents": eventsProcessedDiffByChain
-        ->ChainId.Dict.dangerouslyGetNonOption(chainId)
-        ->Option.getOr(0.),
+        "rollbackedEvents": progressDiff->Option.mapOr(0., diff => diff.eventsProcessed),
       })
-      ->ignore
     }
   })
 
   let diff = await state->InMemoryStore.prepareRollbackDiff(
-    ~rollbackTargetCheckpointId,
+    ~floors,
     ~rollbackDiffCheckpointId=state->IndexerState.committedCheckpointId->BigInt.add(1n),
-    ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
+    ~progressedChains=rolledBackChains,
     ~rolledBackAddresses,
   )
 
-  rolledBackChains->Array.forEach(rolledBack => {
-    logger->Logging.childInfo({
-      "msg": "Rollbacked",
-      "chainId": rolledBack["chainId"],
-      "fromBlock": rolledBack["fromBlock"],
-      "toBlock": rolledBack["toBlock"],
-      "rollbackedEvents": rolledBack["rollbackedEvents"],
-    })
-  })
   logger->Logging.childTrace({
     "msg": "Rollback entity changes",
     "deleted": diff["deletedEntities"],
@@ -217,7 +236,11 @@ and executeRollback = async (
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )
 
-  state->IndexerState.completeRollback(~eventsProcessedDiffByChain)
+  state->IndexerState.completeRollback(
+    ~eventsProcessedDiffByChain=progressDiffByChain->Utils.Dict.mapValues(diff =>
+      diff.eventsProcessed
+    ),
+  )
   scheduleFetch()
   scheduleProcessing()
 }

package/src/Rollback.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
@@ -12,6 +13,7 @@ import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as RollbackFloors from "./db/RollbackFloors.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -42,50 +44,67 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   await Writing.flush(state);
   let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
-  let eventsProcessedDiffByChain = {};
-  let newProgressBlockNumberPerChain = {};
+  let next = Config.isIsolatedMultichain(IndexerState.config(state)) ? RollbackFloors.isolated(reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber) : RollbackFloors.global(rollbackTargetCheckpointId, reorgChain, rollbackTargetBlockNumber);
+  let match = IndexerState.pendingRollback(state);
+  let floors = match !== undefined ? RollbackFloors.merge(match.floors, next) : next;
+  let progressDiffByChain = {};
   let rollbackedProcessedEvents = 0;
-  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(floors);
   for (let idx = 0, idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx) {
     let diff = rollbackProgressDiff[idx];
-    let eventsProcessedDiff = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
-    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
-    eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
-    newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
+    let chainId = diff.chain_id;
+    let eventsProcessed = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
+    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessed;
+    progressDiffByChain[chainId] = {
+      blockNumber: diff.new_progress_block_number,
+      eventsProcessed: eventsProcessed
+    };
   }
   let rolledBackChains = [];
   let rolledBackAddresses = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
     let fromBlock = ChainState.committedProgressBlockNumber(cs);
-    let killedAddresses = ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let progressDiff = progressDiffByChain[chainId];
+    let match = RollbackFloors.forkBlockNumber(floors, chainId);
+    let killedAddresses = ChainState.rollback(cs, progressDiff !== undefined ? ({
+        TAG: "RecomputedProgress",
+        _0: {
+          blockNumber: Stdlib_Option.mapOr(match, progressDiff.blockNumber, forkBlockNumber => Primitive_int.min(progressDiff.blockNumber, forkBlockNumber)),
+          eventsProcessed: progressDiff.eventsProcessed
+        }
+      }) : (
+        match !== undefined ? ({
+            TAG: "ForkBlock",
+            _0: match
+          }) : "Untouched"
+      ));
     rolledBackAddresses.push(...killedAddresses);
     let toBlock = ChainState.committedProgressBlockNumber(cs);
     if (fromBlock !== toBlock) {
       rolledBackChains.push({
+        chainId: chainId,
+        progressBlockNumber: toBlock,
+        sourceBlockNumber: ChainState.knownHeight(cs),
+        totalEventsProcessed: ChainState.numEventsProcessed(cs)
+      });
+      return Logging.childInfo(logger, {
+        msg: "Rollbacked",
         chainId: chainId,
         fromBlock: fromBlock,
         toBlock: toBlock,
-        rollbackedEvents: Stdlib_Option.getOr(eventsProcessedDiffByChain[chainId], 0)
+        rollbackedEvents: Stdlib_Option.mapOr(progressDiff, 0, diff => diff.eventsProcessed)
       });
-      return;
     }
   });
-  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain, rolledBackAddresses);
-  rolledBackChains.forEach(rolledBack => Logging.childInfo(logger, {
-    msg: "Rollbacked",
-    chainId: rolledBack.chainId,
-    fromBlock: rolledBack.fromBlock,
-    toBlock: rolledBack.toBlock,
-    rollbackedEvents: rolledBack.rollbackedEvents
-  }));
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, floors, IndexerState.committedCheckpointId(state) + 1n, rolledBackChains, rolledBackAddresses);
   Logging.childTrace(logger, {
     msg: "Rollback entity changes",
     deleted: diff$1.deletedEntities,
     upserted: diff$1.setEntities
   });
   IndexerState.recordRollbackSuccess(state, Performance.secondsSince(startTime), rollbackedProcessedEvents);
-  IndexerState.completeRollback(state, eventsProcessedDiffByChain);
+  IndexerState.completeRollback(state, Utils.Dict.mapValues(progressDiffByChain, diff => diff.eventsProcessed));
   scheduleFetch();
   return scheduleProcessing();
 }

package/src/RollbackCommit.res

@@ -20,15 +20,13 @@ let register = (callback: callback) => {
     }
 }
 
-// Fired after a rollback diff is durably written, once per affected chain.
-// `progressBlockNumberByChainId` is the last valid block per chain, taken from
-// the in-memory store's rollback object. A throwing callback bubbles to the
-// write loop's onError, crashing the indexer like a failed write.
-let fire = async (~progressBlockNumberByChainId: dict<int>) => {
-  let _ = await progressBlockNumberByChainId
-  ->Dict.toArray
-  ->Array.flatMap(((chainIdKey, rollbackToBlock)) => {
-    let args = {chainId: chainIdKey->ChainId.normalizeOrThrow, rollbackToBlock}
+// Fired after a rollback diff is durably written, once per affected chain, with
+// the last valid block the rollback left that chain at. A throwing callback
+// bubbles to the write loop's onError, crashing the indexer like a failed write.
+let fire = async (~progressedChains: array<InternalTable.Chains.progressedChain>) => {
+  let _ = await progressedChains
+  ->Array.flatMap(({chainId, progressBlockNumber}) => {
+    let args = {chainId, rollbackToBlock: progressBlockNumber}
     callbacks->Array.map(callback => callback(args))
   })
   ->Promise.all

package/src/RollbackCommit.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as ChainId from "./ChainId.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
 let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
@@ -16,10 +15,10 @@ function register(callback) {
   };
 }
 
-async function fire(progressBlockNumberByChainId) {
-  await Promise.all(Object.entries(progressBlockNumberByChainId).flatMap(param => {
-    let args_chainId = ChainId.normalizeOrThrow(param[0]);
-    let args_rollbackToBlock = param[1];
+async function fire(progressedChains) {
+  await Promise.all(progressedChains.flatMap(param => {
+    let args_chainId = param.chainId;
+    let args_rollbackToBlock = param.progressBlockNumber;
     let args = {
       chainId: args_chainId,
       rollbackToBlock: args_rollbackToBlock
@@ -33,4 +32,4 @@ export {
   register,
   fire,
 }
-/* ChainId Not a pure module */
+/* EnvioGlobal Not a pure module */

package/src/SafeCheckpointTracking.res

@@ -33,15 +33,15 @@ let make = (
   }
 }
 
-let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) => {
+let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int): option<
+  Internal.checkpointId,
+> => {
   let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
 
   switch safeCheckpointTracking.checkpointIds {
-  | [] => 0n
-  | _
-    if safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(0) >
-      safeBlockNumber => 0n
-  | [checkpointId] => checkpointId
+  | [] => None
+  | _ if safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(0) > safeBlockNumber => None
+  | [checkpointId] => Some(checkpointId)
   | _ => {
       let trackingCheckpointsCount = safeCheckpointTracking.checkpointIds->Array.length
       let result = ref(None)
@@ -52,16 +52,15 @@ let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) =
           safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(idx.contents) >
             safeBlockNumber
         ) {
-          result :=
-            Some(safeCheckpointTracking.checkpointIds->Array.getUnsafe(idx.contents - 1))
+          result := Some(safeCheckpointTracking.checkpointIds->Array.getUnsafe(idx.contents - 1))
         }
         idx := idx.contents + 1
       }
 
       switch result.contents {
-      | Some(checkpointId) => checkpointId
+      | Some(_) => result.contents
       | None =>
-        safeCheckpointTracking.checkpointIds->Array.getUnsafe(trackingCheckpointsCount - 1)
+        Some(safeCheckpointTracking.checkpointIds->Array.getUnsafe(trackingCheckpointsCount - 1))
       }
     }
   }
@@ -75,7 +74,8 @@ let updateOnNewBatch = (
   ~batchCheckpointBlockNumbers: array<int>,
   ~batchCheckpointChainIds: array<ChainId.t>,
 ) => {
-  let safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, ~sourceBlockNumber)
+  let safeCheckpointId =
+    getSafeCheckpointId(safeCheckpointTracking, ~sourceBlockNumber)->Option.getOr(0n)
 
   let mutCheckpointIds = []
   let mutCheckpointBlockNumbers = []

package/src/SafeCheckpointTracking.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
   if (!(maxReorgDepth > 0 && shouldRollbackOnReorg)) {
@@ -22,10 +23,10 @@ function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
   let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
   let match = safeCheckpointTracking.checkpointIds;
   if (match.length === 0) {
-    return 0n;
+    return;
   }
   if (safeCheckpointTracking.checkpointBlockNumbers[0] > safeBlockNumber) {
-    return 0n;
+    return;
   }
   if (match.length === 1) {
     return match[0];
@@ -39,16 +40,16 @@ function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
     }
     idx = idx + 1 | 0;
   };
-  let checkpointId = result;
-  if (checkpointId !== undefined) {
-    return checkpointId;
+  let match$1 = result;
+  if (match$1 !== undefined) {
+    return result;
   } else {
     return safeCheckpointTracking.checkpointIds[trackingCheckpointsCount - 1 | 0];
   }
 }
 
 function updateOnNewBatch(safeCheckpointTracking, sourceBlockNumber, chainId, batchCheckpointIds, batchCheckpointBlockNumbers, batchCheckpointChainIds) {
-  let safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber);
+  let safeCheckpointId = Stdlib_Option.getOr(getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber), 0n);
   let mutCheckpointIds = [];
   let mutCheckpointBlockNumbers = [];
   for (let idx = 0, idx_finish = safeCheckpointTracking.checkpointIds.length; idx < idx_finish; ++idx) {

package/src/SimulateItems.res

@@ -338,11 +338,12 @@ let parse = (
       | None =>
         switch blockJson {
         | Some(bj) =>
-          switch (bj->(Utils.magic: JSON.t => dict<JSON.t>))->Dict.get("slot") {
+          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,
-            )
+            v
+            ->(Utils.magic: JSON.t => Nullable.t<int>)
+            ->Nullable.toOption
+            ->Option.getOr(currentBlock.contents)
           | None => currentBlock.contents
           }
         | None => currentBlock.contents
@@ -371,13 +372,23 @@ let parse = (
         | None => []
         }
       }
-      let data = item.data->Option.getOr(svmEventConfig.discriminator->Option.getOr("0x"))
-      let argsJson = item.args->Option.mapOr("{}", args => args->JSON.stringify)
+      let data = switch (item.data, svmEventConfig.discriminator) {
+      | (Some(data), _) => data
+      | (None, Some(discriminator)) =>
+        discriminator
+        ->String.replace("0x", "")
+        ->NodeJs.Buffer.fromHex
+        ->Uint8Array.fromArrayLikeOrIterable
+      | (None, None) => Uint8Array.fromLength(0)
+      }
+      let args = item.args->Option.getOr(Dict.make()->(Utils.magic: dict<unknown> => unknown))
       let logs = item.logs->Option.map(logs =>
-        logs->Array.map((log): SvmHyperSyncClient.EventItems.log => {
-          kind: log.kind->Null.fromOption,
-          message: log.message->Null.fromOption,
-        })
+        logs->Array.map(
+          (log): SvmHyperSyncClient.EventItems.log => {
+            kind: log.kind->Null.fromOption,
+            message: log.message->Null.fromOption,
+          },
+        )
       )
 
       let liveRegistrations = liveRegistrationsFor(~config, ~chainId, ~eventConfig)
@@ -414,13 +425,13 @@ let parse = (
             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),
+            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
         )
@@ -456,7 +467,11 @@ let parse = (
             accounts: accountArguments,
             data,
             isInner: item.isInner->Option.getOr(false),
-            argsJson,
+            // As the Rust client does: present exactly when this registration
+            // selected `args`.
+            args: onEventRegistration.fieldSelection.instructionFields->Utils.Set.has("args")
+              ? Null.make(args)
+              : Null.null,
             logs: logs->Null.fromOption,
           },
           ~programName,

package/src/SimulateItems.res.mjs

@@ -245,8 +245,12 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
               }
             }) : [];
         }
-        let data = Stdlib_Option.getOr(rawJson.data, Stdlib_Option.getOr(eventConfig.discriminator, "0x"));
-        let argsJson = Stdlib_Option.mapOr(rawJson.args, "{}", args => JSON.stringify(args));
+        let match$3 = rawJson.data;
+        let match$4 = eventConfig.discriminator;
+        let data = match$3 !== undefined ? match$3 : (
+            match$4 !== undefined ? Uint8Array.from(Buffer.from(match$4.replace("0x", ""), "hex")) : new Uint8Array(0)
+          );
+        let args$1 = Stdlib_Option.getOr(rawJson.args, {});
         let logs = Stdlib_Option.map(rawJson.logs, logs => logs.map(log => ({
           kind: Stdlib_Null.fromOption(log.kind),
           message: Stdlib_Null.fromOption(log.message)
@@ -312,7 +316,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
             accounts: accountArguments,
             data: data,
             isInner: Stdlib_Option.getOr(rawJson.isInner, false),
-            argsJson: argsJson,
+            args: newrecord.fieldSelection.instructionFields.has("args") ? args$1 : null,
             logs: Stdlib_Null.fromOption(logs)
           }, match$1, match$2, eventConfig, newrecord.fieldSelection);
           payload["srcAddress"] = programId;
@@ -329,14 +333,14 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         });
         return;
     }
-    let match$3 = rawJson.contract;
-    let match$4 = rawJson.event;
-    let match$5 = match$3 !== undefined && match$4 !== undefined ? [
-        match$3,
-        match$4
+    let match$5 = rawJson.contract;
+    let match$6 = rawJson.event;
+    let match$7 = match$5 !== undefined && match$6 !== undefined ? [
+        match$5,
+        match$6
       ] : Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
-    let eventName = match$5[1];
-    let contractName = match$5[0];
+    let eventName = match$7[1];
+    let contractName = match$7[0];
     let ec$1 = findEventConfig(config, contractName, eventName);
     let eventConfig$1 = ec$1 !== undefined ? ec$1 : Stdlib_JsError.throwWithMessage(`simulate: Event "` + eventName + `" not found on contract "` + contractName + `". Check that the contract and event names match your config.yaml.`);
     let json = rawJson.params;
@@ -359,32 +363,32 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     let blockJson$2 = (blockJson$1 == null) ? undefined : Primitive_option.some(blockJson$1);
     let transactionJson = rawJson.transaction;
     let transactionJson$1 = (transactionJson == null) ? undefined : Primitive_option.some(transactionJson);
-    let match$6 = config.ecosystem.name;
-    let match$7;
-    switch (match$6) {
+    let match$8 = config.ecosystem.name;
+    let match$9;
+    switch (match$8) {
       case "evm" :
         let block$2 = parseEvmSimulateBlock(currentBlock.contents, blockJson$2);
-        match$7 = [
+        match$9 = [
           block$2,
           block$2.number
         ];
         break;
       case "fuel" :
         let block$3 = parseFuelSimulateBlock(currentBlock.contents, blockJson$2);
-        match$7 = [
+        match$9 = [
           block$3,
           block$3.height
         ];
         break;
       case "svm" :
-        match$7 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
+        match$9 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
         break;
     }
-    let blockNumber = match$7[1];
-    let block$4 = match$7[0];
-    let match$8 = config.ecosystem.name;
+    let blockNumber = match$9[1];
+    let block$4 = match$9[0];
+    let match$10 = config.ecosystem.name;
     let transaction$1;
-    switch (match$8) {
+    switch (match$10) {
       case "evm" :
         transaction$1 = parseEvmSimulateTransaction(transactionJson$1);
         break;
@@ -411,9 +415,9 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
       }
     });
     if (Utils.$$Array.isEmpty(liveRegistrations$1)) {
-      let match$9 = ChainMap.values(config.chainMap).length;
+      let match$11 = ChainMap.values(config.chainMap).length;
       Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + eventName + `" on contract "` + contractName + `"` + (
-        match$9 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
+        match$11 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
       ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
     }
     liveRegistrations$1.forEach(reg => {