envio 3.7.0 → 3.9.0

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,182 @@ 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 argsJson = item.args->Option.mapOr("{}", args => args->JSON.stringify)
+      let logs = item.logs->Option.map(logs =>
+        logs->Array.map((log): SvmHyperSyncClient.EventItems.log => {
+          kind: log.kind->Null.fromOption,
+          message: log.message->Null.fromOption,
+        })
+      )
+
+      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),
+            argsJson,
+            logs: logs->Null.fromOption,
+          },
+          ~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 +628,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 +681,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

package/src/SimulateItems.res.mjs

@@ -5,11 +5,15 @@ import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
+import * as BlockStore from "./sources/BlockStore.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./sources/TransactionStore.res.mjs";
+import * as SvmHyperSyncSource from "./sources/SvmHyperSyncSource.res.mjs";
 
 let evmSimulateBlockSchema = S$RescriptSchema.schema(s => ({
   number: s.m(S$RescriptSchema.Option.getOr(S$RescriptSchema.$$null(S$RescriptSchema.int), 0)),
@@ -168,6 +172,16 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config)
   }
 }
 
+function liveRegistrationsFor(config, chainId, eventConfig) {
+  return HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+    if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
+      return !HandlerRegister.isDroppedByWhere(config, reg);
+    } else {
+      return false;
+    }
+  });
+}
+
 function parse(simulateItems, config, chainConfig, onEventRegistrations) {
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
@@ -178,21 +192,156 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     contents: 0
   };
   let items = [];
+  let svmTxs = [];
+  let svmActivities = [];
+  let svmBlocks = [];
   let seenCoordinates = {};
   simulateItems.forEach((rawJson, itemIndex) => {
-    let match = rawJson.contract;
-    let match$1 = rawJson.event;
-    if (match === undefined) {
-      return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
-    }
-    if (match$1 === undefined) {
-      return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
+    let match = config.ecosystem.name;
+    let match$1 = rawJson.program;
+    let match$2 = rawJson.instruction;
+    switch (match) {
+      case "evm" :
+      case "fuel" :
+        break;
+      case "svm" :
+        if (match$1 === undefined) {
+          return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "program" and "instruction" fields.`);
+        }
+        if (match$2 === undefined) {
+          return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "program" and "instruction" fields.`);
+        }
+        let ec = findEventConfig(config, match$1, match$2);
+        let eventConfig = ec !== undefined ? ec : Stdlib_JsError.throwWithMessage(`simulate: Instruction "` + match$2 + `" not found on program "` + match$1 + `". Check that the program and instruction names match your config.yaml.`);
+        let blockJson = rawJson.block;
+        let s = rawJson.slot;
+        let slot;
+        if (s !== undefined) {
+          slot = s;
+        } else if (blockJson == null) {
+          slot = currentBlock.contents;
+        } else {
+          let v = blockJson["slot"];
+          slot = v !== undefined ? Stdlib_Option.getOr((v == null) ? undefined : Primitive_option.some(v), currentBlock.contents) : currentBlock.contents;
+        }
+        currentBlock.contents = slot;
+        let tx = rawJson.transaction;
+        let transaction = tx !== undefined ? Primitive_option.valFromOption(tx) : ({});
+        let transactionIndex = Stdlib_Option.getOr(transaction.transactionIndex, 0);
+        let path = Stdlib_Option.getOr(rawJson.path, [0]);
+        let programId = Stdlib_Option.getOr(rawJson.programId, eventConfig.programId);
+        let args = rawJson.accountArguments;
+        let accountArguments;
+        if (args !== undefined) {
+          accountArguments = args;
+        } else {
+          let named = rawJson.accounts;
+          accountArguments = named !== undefined ? eventConfig.accounts.map(name => {
+              let match = named[name];
+              if (match !== undefined) {
+                return match.address;
+              } else {
+                return "";
+              }
+            }) : [];
+        }
+        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 logs = Stdlib_Option.map(rawJson.logs, logs => logs.map(log => ({
+          kind: Stdlib_Null.fromOption(log.kind),
+          message: Stdlib_Null.fromOption(log.message)
+        })));
+        let liveRegistrations = liveRegistrationsFor(config, chainId, eventConfig);
+        if (Utils.$$Array.isEmpty(liveRegistrations)) {
+          Stdlib_JsError.throwWithMessage(`simulate: no handler runs for instruction "` + match$2 + `" on program "` + match$1 + `". Register a handler with indexer.onInstruction before simulating it.`);
+        }
+        svmTxs.push({
+          slot: slot,
+          transactionIndex: 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
+        });
+        let rows = transaction.accountActivities;
+        if (rows !== undefined) {
+          rows.forEach(activity => {
+            svmActivities.push({
+              slot: slot,
+              transactionIndex: transactionIndex,
+              account: activity.address,
+              accountIndex: activity.transactionAccountIndex,
+              isSigner: activity.isSigner,
+              isWritable: activity.isWritable,
+              preBalance: Stdlib_Option.flatMap(activity.lamports, l => l.pre),
+              postBalance: Stdlib_Option.flatMap(activity.lamports, l => l.post),
+              mint: Stdlib_Option.flatMap(activity.token, t => t.mint),
+              owner: Stdlib_Option.flatMap(activity.token, t => t.owner),
+              decimals: Stdlib_Option.flatMap(activity.token, t => t.decimals),
+              preAmount: Stdlib_Option.flatMap(activity.token, t => t.preAmount),
+              postAmount: Stdlib_Option.flatMap(activity.token, t => t.postAmount)
+            });
+          });
+        }
+        let block = rawJson.block;
+        let blockTime = block !== undefined ? block.time : undefined;
+        let block$1 = rawJson.block;
+        let blockHash = block$1 !== undefined ? block$1.hash : undefined;
+        svmBlocks.push({
+          blockNumber: slot,
+          blockHash: blockHash,
+          blockTimestamp: blockTime
+        });
+        liveRegistrations.forEach(reg => {
+          let onEventRegistrationIndex = onEventRegistrations.length;
+          let newrecord = {...reg};
+          newrecord.index = onEventRegistrationIndex;
+          onEventRegistrations.push(newrecord);
+          let payload = SvmHyperSyncSource.toSvmInstruction({
+            onEventRegistrationIndex: onEventRegistrationIndex,
+            slot: slot,
+            transactionIndex: transactionIndex,
+            path: path,
+            programId: programId,
+            accounts: accountArguments,
+            data: data,
+            isInner: Stdlib_Option.getOr(rawJson.isInner, false),
+            argsJson: argsJson,
+            logs: Stdlib_Null.fromOption(logs)
+          }, match$1, match$2, eventConfig, newrecord.fieldSelection);
+          payload["srcAddress"] = programId;
+          items.push({
+            kind: 0,
+            onEventRegistration: newrecord,
+            chainId: chainId,
+            blockNumber: slot,
+            logIndex: transactionIndex,
+            orderPath: path,
+            transactionIndex: transactionIndex,
+            payload: payload
+          });
+        });
+        return;
     }
-    let ec = findEventConfig(config, match, match$1);
-    let eventConfig = ec !== undefined ? ec : Stdlib_JsError.throwWithMessage(`simulate: Event "` + match$1 + `" not found on contract "` + match + `". Check that the contract and event names match your config.yaml.`);
+    let match$3 = rawJson.contract;
+    let match$4 = rawJson.event;
+    let match$5 = match$3 !== undefined && match$4 !== undefined ? [
+        match$3,
+        match$4
+      ] : 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 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;
     let paramsJson = json !== undefined ? json : ({});
-    let params = S$RescriptSchema.convertOrThrow(paramsJson, eventConfig.simulateParamsSchema);
+    let params = S$RescriptSchema.convertOrThrow(paramsJson, eventConfig$1.simulateParamsSchema);
     let li = rawJson.logIndex;
     let logIndex;
     if (li !== undefined) {
@@ -205,45 +354,45 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig, config);
-    let blockJson = rawJson.block;
-    let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig$1, chainConfig, config);
+    let blockJson$1 = rawJson.block;
+    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$2 = config.ecosystem.name;
-    let match$3;
-    switch (match$2) {
+    let match$6 = config.ecosystem.name;
+    let match$7;
+    switch (match$6) {
       case "evm" :
-        let block = parseEvmSimulateBlock(currentBlock.contents, blockJson$1);
-        match$3 = [
-          block,
-          block.number
+        let block$2 = parseEvmSimulateBlock(currentBlock.contents, blockJson$2);
+        match$7 = [
+          block$2,
+          block$2.number
         ];
         break;
       case "fuel" :
-        let block$1 = parseFuelSimulateBlock(currentBlock.contents, blockJson$1);
-        match$3 = [
-          block$1,
-          block$1.height
+        let block$3 = parseFuelSimulateBlock(currentBlock.contents, blockJson$2);
+        match$7 = [
+          block$3,
+          block$3.height
         ];
         break;
       case "svm" :
-        match$3 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
+        match$7 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
         break;
     }
-    let blockNumber = match$3[1];
-    let block$2 = match$3[0];
-    let match$4 = config.ecosystem.name;
-    let transaction;
-    switch (match$4) {
+    let blockNumber = match$7[1];
+    let block$4 = match$7[0];
+    let match$8 = config.ecosystem.name;
+    let transaction$1;
+    switch (match$8) {
       case "evm" :
-        transaction = parseEvmSimulateTransaction(transactionJson$1);
+        transaction$1 = parseEvmSimulateTransaction(transactionJson$1);
         break;
       case "fuel" :
-        transaction = parseFuelSimulateTransaction(transactionJson$1);
+        transaction$1 = parseFuelSimulateTransaction(transactionJson$1);
         break;
       case "svm" :
-        transaction = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
+        transaction$1 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
         break;
     }
     currentBlock.contents = blockNumber;
@@ -254,20 +403,20 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
-    let liveRegistrations = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+    let liveRegistrations$1 = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig$1).filter(reg => {
       if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
         return !HandlerRegister.isDroppedByWhere(config, reg);
       } else {
         return false;
       }
     });
-    if (Utils.$$Array.isEmpty(liveRegistrations)) {
-      let match$5 = ChainMap.values(config.chainMap).length;
-      Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + match$1 + `" on contract "` + match + `"` + (
-        match$5 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
+    if (Utils.$$Array.isEmpty(liveRegistrations$1)) {
+      let match$9 = 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) : ""
       ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
     }
-    liveRegistrations.forEach(reg => {
+    liveRegistrations$1.forEach(reg => {
       let onEventRegistrationIndex = onEventRegistrations.length;
       let newrecord = {...reg};
       newrecord.index = onEventRegistrationIndex;
@@ -280,19 +429,34 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         logIndex: logIndex,
         transactionIndex: 0,
         payload: {
-          contractName: eventConfig.contractName,
-          eventName: eventConfig.name,
+          contractName: eventConfig$1.contractName,
+          eventName: eventConfig$1.name,
           params: params,
           chainId: chainId,
           srcAddress: srcAddress,
           logIndex: logIndex,
-          transaction: Primitive_option.some(transaction),
-          block: Primitive_option.some(block$2)
+          transaction: Primitive_option.some(transaction$1),
+          block: Primitive_option.some(block$4)
         }
       });
     });
   });
-  return items;
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+    case "fuel" :
+      return {
+        items: items,
+        transactionStore: undefined,
+        blockStore: undefined
+      };
+    case "svm" :
+      return {
+        items: items,
+        transactionStore: Primitive_option.some(TransactionStore.fromSvmJs(svmTxs, svmActivities)),
+        blockStore: Primitive_option.some(BlockStore.fromJs(svmBlocks, "svm", false))
+      };
+  }
 }
 
 function patchConfig(config, processConfig, registrationsByChainId) {
@@ -329,12 +493,14 @@ function patchConfig(config, processConfig, registrationsByChainId) {
     let newrecord = {...chainConfig};
     newrecord.endBlock = endBlock;
     newrecord.startBlock = startBlock;
-    let items = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
+    let match = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
     let newrecord$1 = {...newrecord};
     newrecord$1.sourceConfig = {
       TAG: "SimulateSourceConfig",
-      items: items,
-      endBlock: endBlock
+      items: match.items,
+      endBlock: endBlock,
+      transactionStore: match.transactionStore,
+      blockStore: match.blockStore
     };
     return newrecord$1;
   });
@@ -356,6 +522,7 @@ export {
   dummySrcAddress,
   firstContractAddress,
   deriveSrcAddress,
+  liveRegistrationsFor,
   parse,
   patchConfig,
 }