envio 3.7.0 → 3.8.0

package/src/db/InternalTable.res

@@ -17,6 +17,7 @@ module Chains = {
   type field = [
     | progressFields
     | #id
+    | #ecosystem
     | #start_block
     | #end_block
     | #max_reorg_depth
@@ -29,6 +30,7 @@ module Chains = {
 
   let fields: array<field> = [
     #id,
+    #ecosystem,
     #start_block,
     #end_block,
     #max_reorg_depth,
@@ -57,6 +59,7 @@ module Chains = {
 
   type t = {
     @as("id") id: ChainId.t,
+    @as("ecosystem") ecosystem: string,
     @as("start_block") startBlock: int,
     @as("end_block") endBlock: Null.t<int>,
     @as("max_reorg_depth") maxReorgDepth: int,
@@ -70,6 +73,10 @@ module Chains = {
     "envio_chains",
     ~fields=[
       mkField((#id: field :> string), ChainId, ~fieldSchema=ChainId.schema, ~isPrimaryKey),
+      // Which ecosystem the chain belongs to (evm / fuel / svm). Chain ids are
+      // only unique within an ecosystem (HOS-1880: Svm ids are Envio-assigned),
+      // so consumers should treat (ecosystem, id) as the chain's identity.
+      mkField((#ecosystem: field :> string), String, ~fieldSchema=S.string),
       // Values populated from config
       mkField((#start_block: field :> string), Int32, ~fieldSchema=S.int),
       mkField((#end_block: field :> string), Int32, ~fieldSchema=S.null(S.int), ~isNullable),
@@ -104,6 +111,7 @@ module Chains = {
   let initialFromConfig = (chainConfig: Config.chain) => {
     {
       id: chainConfig.id,
+      ecosystem: (chainConfig.ecosystem: Ecosystem.name :> string),
       startBlock: chainConfig.startBlock,
       endBlock: chainConfig.endBlock->Null.fromOption,
       maxReorgDepth: chainConfig.maxReorgDepth,
@@ -131,6 +139,7 @@ module Chains = {
           let value = initialValues->(Utils.magic: t => dict<unknown>)->Dict.get((field :> string))
           switch typeof(value) {
           | #object => "NULL"
+          | #string => `'${value->(Utils.magic: option<unknown> => string)}'`
           | #number => value->(Utils.magic: option<unknown> => int)->Int.toString
           | #bigint => value->(Utils.magic: option<unknown> => bigint)->BigInt.toString
           | #boolean => value->(Utils.magic: option<unknown> => bool) ? "true" : "false"
@@ -648,6 +657,7 @@ module Views = {
     `CREATE VIEW "${pgSchema}"."${metaViewName}" AS 
 SELECT 
   "${(#id: Chains.field :> string)}" AS "chainId",
+  "${(#ecosystem: Chains.field :> string)}" AS "ecosystem",
   "${(#start_block: Chains.field :> string)}" AS "startBlock", 
   "${(#end_block: Chains.field :> string)}" AS "endBlock",
   "${(#progress_block: Chains.field :> string)}" AS "progressBlock",
@@ -666,6 +676,7 @@ ORDER BY "${(#id: Chains.field :> string)}";`
 SELECT 
   "${(#source_block: Chains.field :> string)}" AS "block_height",
   "${(#id: Chains.field :> string)}" AS "chain_id",
+  "${(#ecosystem: Chains.field :> string)}" AS "ecosystem",
   "${(#end_block: Chains.field :> string)}" AS "end_block", 
   "${(#first_event_block: Chains.field :> string)}" AS "first_event_block_number",
   "${(#_is_hyper_sync: Chains.field :> string)}" AS "is_hyper_sync",

package/src/db/InternalTable.res.mjs

@@ -13,6 +13,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 
 let fields = [
   "id",
+  "ecosystem",
   "start_block",
   "end_block",
   "max_reorg_depth",
@@ -27,6 +28,7 @@ let fields = [
 
 let table = Table.mkTable("envio_chains", undefined, [
   Table.mkField("id", "ChainId", ChainId.schema, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
+  Table.mkField("ecosystem", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("start_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("end_block", "Int32", S$RescriptSchema.$$null(S$RescriptSchema.int), undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
   Table.mkField("max_reorg_depth", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -42,6 +44,7 @@ let table = Table.mkTable("envio_chains", undefined, [
 function initialFromConfig(chainConfig) {
   return {
     id: chainConfig.id,
+    ecosystem: chainConfig.ecosystem,
     start_block: chainConfig.startBlock,
     end_block: Stdlib_Null.fromOption(chainConfig.endBlock),
     max_reorg_depth: chainConfig.maxReorgDepth,
@@ -73,6 +76,8 @@ function makeInitialValuesQuery(pgSchema, chainConfigs) {
         } else {
           return "false";
         }
+      } else if (match === "string") {
+        return `'` + value + `'`;
       } else if (match === "object") {
         return "NULL";
       } else {
@@ -440,6 +445,7 @@ function makeMetaViewQuery(pgSchema) {
   return `CREATE VIEW "` + pgSchema + `"."` + metaViewName + `" AS 
 SELECT 
   "` + "id" + `" AS "chainId",
+  "` + "ecosystem" + `" AS "ecosystem",
   "` + "start_block" + `" AS "startBlock", 
   "` + "end_block" + `" AS "endBlock",
   "` + "progress_block" + `" AS "progressBlock",
@@ -458,6 +464,7 @@ function makeChainMetadataViewQuery(pgSchema) {
 SELECT 
   "` + "source_block" + `" AS "block_height",
   "` + "id" + `" AS "chain_id",
+  "` + "ecosystem" + `" AS "ecosystem",
   "` + "end_block" + `" AS "end_block", 
   "` + "first_event_block" + `" AS "first_event_block_number",
   "` + "_is_hyper_sync" + `" AS "is_hyper_sync",

package/src/sources/EvmHyperSyncSource.res

@@ -1,7 +1,8 @@
 open Source
 
-// Surfaced by HyperSyncClient.getHeight (Rust) when HyperSync rejects the API
-// token. The corrupted-token test feeds the real server error through this
+// Surfaced by the HyperSync client (Rust) when HyperSync rejects the API
+// token. The corrupted-token test feeds the real server error (from the query
+// endpoint; the edge no longer 401s malformed tokens on /height) through this
 // check so it can't silently drift away from what getHeightOrThrow guards on.
 let isUnauthorizedError = (message: string) => message->String.includes("401 Unauthorized")
 

package/src/sources/SimulateSource.res

@@ -4,6 +4,8 @@ let make = (
   ~chainId: ChainId.t,
   ~addressStore: AddressStore.t,
   ~ecosystem: Ecosystem.name=Evm,
+  ~transactionStore: option<TransactionStore.t>=None,
+  ~blockStore: option<BlockStore.t>=None,
 ): Source.t => {
   let reportedHeight = max(endBlock, 1)
 
@@ -106,10 +108,12 @@ let make = (
       Promise.resolve({
         Source.knownHeight: reportedHeight,
         parsedQueueItems,
-        // Simulate keeps the transaction and block inline on the payload; no
-        // transaction page and an empty block page (nothing to reorg-check).
-        transactionStore: None,
-        blockStore: BlockStore.fromJs([], ~ecosystem, ~shouldChecksum=false),
+        // EVM/Fuel keep transaction and block inline. SVM simulate returns a
+        // store page so materialize + activity attach run the same path as HyperSync.
+        transactionStore,
+        blockStore: blockStore->Option.getOr(
+          BlockStore.fromJs([], ~ecosystem, ~shouldChecksum=false),
+        ),
         fromBlockQueried: fromBlock,
         latestFetchedBlockNumber: toBlockQueried,
         stats: {

package/src/sources/SimulateSource.res.mjs

@@ -2,9 +2,13 @@
 
 import * as BlockStore from "./BlockStore.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-function make(items, endBlock, chainId, addressStore, ecosystemOpt) {
+function make(items, endBlock, chainId, addressStore, ecosystemOpt, transactionStoreOpt, blockStoreOpt) {
   let ecosystem = ecosystemOpt !== undefined ? ecosystemOpt : "evm";
+  let transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : undefined;
+  let blockStore = blockStoreOpt !== undefined ? Primitive_option.valFromOption(blockStoreOpt) : undefined;
   let reportedHeight = Primitive_int.max(endBlock, 1);
   return {
     name: "SimulateSource",
@@ -75,8 +79,8 @@ function make(items, endBlock, chainId, addressStore, ecosystemOpt) {
       return Promise.resolve({
         knownHeight: reportedHeight,
         parsedQueueItems: parsedQueueItems,
-        transactionStore: undefined,
-        blockStore: BlockStore.fromJs([], ecosystem, false),
+        transactionStore: transactionStore,
+        blockStore: Stdlib_Option.getOr(blockStore, BlockStore.fromJs([], ecosystem, false)),
         fromBlockQueried: fromBlock,
         latestFetchedBlockNumber: toBlockQueried,
         stats: {

package/src/sources/Svm.res

@@ -14,13 +14,38 @@ let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 // Rust store (`SvmBlockField`) — keep this order in sync.
 let blockFields = ["slot", "time", "hash", "height", "parentSlot", "parentHash"]
 
-// `slot`/`time`/`hash` are always included; every other block field is opt-in
-// via `field_selection.block_fields`. All are materialised from the store.
+// `slot` is always included (the item's key); every other block field is
+// opt-in via handler `fields.block`. All are materialised from the store.
 //
 // One instruction's selected block fields → store selection bitmask. Computed per
 // event at config build and cached on the event config.
 let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
 
+let attachAccountActivities = (payload: Internal.eventPayload, tx: Internal.eventTransaction) => {
+  let instruction = payload->(Utils.magic: Internal.eventPayload => dict<unknown>)
+  let transaction = tx->(Utils.magic: Internal.eventTransaction => dict<unknown>)
+  switch (instruction->Dict.get("accounts"), transaction->Dict.get("accountActivities")) {
+  | (Some(accounts), Some(activities)) if !(accounts->Array.isArray) =>
+    let byAddress = Dict.make()
+    (activities->(Utils.magic: unknown => array<Envio.svmAccountActivity>))->Array.forEach(
+      activity => byAddress->Dict.set(activity.address->SvmTypes.Pubkey.toString, activity),
+    )
+    (accounts->(Utils.magic: unknown => dict<Envio.svmInstructionAccount>))
+    ->Dict.valuesToArray
+    ->Array.forEach(account =>
+      switch byAddress->Dict.get(account.address->SvmTypes.Pubkey.toString) {
+      | Some(activity) =>
+        (account->(Utils.magic: Envio.svmInstructionAccount => dict<unknown>))->Dict.set(
+          "activity",
+          activity->(Utils.magic: Envio.svmAccountActivity => unknown),
+        )
+      | None => ()
+      }
+    )
+  | _ => ()
+  }
+}
+
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
   blockNumberName: "height",
@@ -36,16 +61,18 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   logger,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem => {
-    let instruction =
-      eventItem.payload->(Utils.magic: Internal.eventPayload => Envio.svmInstruction)
+    let eventConfig =
+      eventItem.onEventRegistration.eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig
+      )
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "program": eventItem.onEventRegistration.eventConfig.contractName,
-        "instruction": eventItem.onEventRegistration.eventConfig.name,
+        "program": eventConfig.contractName,
+        "instruction": eventConfig.name,
         "chainId": eventItem.chainId,
         "slot": eventItem.blockNumber,
-        "programId": instruction.programId,
+        "programId": eventConfig.programId,
       },
     )
   },

package/src/sources/Svm.res.mjs

@@ -9,6 +9,7 @@ import * as Internal from "../Internal.res.mjs";
 import * as BlockStore from "./BlockStore.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+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 "./TransactionStore.res.mjs";
 
@@ -25,6 +26,32 @@ let blockFields = [
 
 let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
 
+function attachAccountActivities(payload, tx) {
+  let match = payload["accounts"];
+  let match$1 = tx["accountActivities"];
+  if (match === undefined) {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  let accounts = Primitive_option.valFromOption(match);
+  if (Array.isArray(accounts)) {
+    return;
+  }
+  let byAddress = {};
+  Primitive_option.valFromOption(match$1).forEach(activity => {
+    byAddress[activity.address] = activity;
+  });
+  Object.values(accounts).forEach(account => {
+    let activity = byAddress[account.address];
+    if (activity !== undefined) {
+      account["activity"] = activity;
+      return;
+    }
+  });
+}
+
 function make(logger) {
   return {
     name: "svm",
@@ -37,13 +64,13 @@ function make(logger) {
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => {
-      let instruction = eventItem.payload;
+      let eventConfig = eventItem.onEventRegistration.eventConfig;
       return Logging.createChildFrom(logger, {
-        program: eventItem.onEventRegistration.eventConfig.contractName,
-        instruction: eventItem.onEventRegistration.eventConfig.name,
+        program: eventConfig.contractName,
+        instruction: eventConfig.name,
         chainId: eventItem.chainId,
         slot: eventItem.blockNumber,
-        programId: instruction.programId
+        programId: eventConfig.programId
       });
     },
     toRawEvent: param => Stdlib_JsError.throwWithMessage("Raw events are not supported for SVM")
@@ -96,6 +123,7 @@ export {
   eventTransactionFieldMask,
   blockFields,
   eventBlockFieldMask,
+  attachAccountActivities,
   make,
   GetFinalizedSlot,
   makeRPCSource,

package/src/sources/SvmHyperSyncClient.res

@@ -27,14 +27,15 @@ module Registration = {
     // Earliest slot this registration accepts; `None` is unrestricted.
     startBlock: option<int>,
     discriminator?: string,
-    discriminatorByteLen: int,
     isInner?: bool,
-    includeLogs: bool,
     // DNF: outer array is OR of AND-groups.
     accountFilters: array<array<accountFilter>>,
     // camelCase Internal.svmTransactionField / svmBlockField names.
     transactionFields: array<string>,
     blockFields: array<string>,
+    accountActivityFields: array<string>,
+    logFields: array<string>,
+    instructionFields: array<string>,
     // Borsh schema pieces; empty accounts + absent argsJson = no schema.
     accounts: array<string>,
     argsJson?: string,
@@ -55,9 +56,7 @@ module Registration = {
         isWildcard: reg.isWildcard,
         startBlock: reg.startBlock,
         discriminator: ?eventConfig.discriminator,
-        discriminatorByteLen: eventConfig.discriminatorByteLen,
         isInner: ?eventConfig.isInner,
-        includeLogs: eventConfig.includeLogs,
         accountFilters: eventConfig.accountFilters->Array.map(group =>
           group->Array.map(
             (filter): accountFilter => {
@@ -68,6 +67,9 @@ module Registration = {
         ),
         transactionFields: reg.fieldSelection.transactionFields->Utils.Set.toArray,
         blockFields: reg.fieldSelection.blockFields->Utils.Set.toArray,
+        accountActivityFields: reg.fieldSelection.accountActivityFields->Utils.Set.toArray,
+        logFields: reg.fieldSelection.logFields->Utils.Set.toArray,
+        instructionFields: reg.fieldSelection.instructionFields->Utils.Set.toArray,
         accounts: eventConfig.accounts,
         argsJson: ?switch eventConfig.args {
         | JSON.Null => None
@@ -205,8 +207,8 @@ module EventItems = {
   }
 
   type log = {
-    kind: string,
-    message: string,
+    kind?: string,
+    message?: string,
   }
 
   // One routed instruction; `block` and `transaction` are materialised from
@@ -215,17 +217,13 @@ module EventItems = {
     onEventRegistrationIndex: int,
     slot: int,
     transactionIndex: int,
-    instructionAddress: array<int>,
+    path: array<int>,
     programId: string,
     accounts: array<string>,
     data: string,
-    d1?: string,
-    d2?: string,
-    d4?: string,
-    d8?: string,
     isInner: bool,
     decoded?: ResponseTypes.decodedInstruction,
-    // Present only when the routed registration opted in via `includeLogs`.
+    // Present only when the routed registration selected `fields.log`.
     logs?: array<log>,
   }
 

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -20,15 +20,16 @@ function fromOnEventRegistrations(onEventRegistrations) {
       isWildcard: reg.isWildcard,
       startBlock: reg.startBlock,
       discriminator: eventConfig.discriminator,
-      discriminatorByteLen: eventConfig.discriminatorByteLen,
       isInner: eventConfig.isInner,
-      includeLogs: eventConfig.includeLogs,
       accountFilters: eventConfig.accountFilters.map(group => group.map(filter => ({
         position: filter.position,
         values: filter.values
       }))),
       transactionFields: Array.from(reg.fieldSelection.transactionFields),
       blockFields: Array.from(reg.fieldSelection.blockFields),
+      accountActivityFields: Array.from(reg.fieldSelection.accountActivityFields),
+      logFields: Array.from(reg.fieldSelection.logFields),
+      instructionFields: Array.from(reg.fieldSelection.instructionFields),
       accounts: eventConfig.accounts,
       argsJson: tmp,
       definedTypesJson: tmp$1

package/src/sources/SvmHyperSyncSource.res

@@ -10,50 +10,105 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-// Parse the Rust-decoded instruction (args/accounts arrive as JSON strings to
-// side-step napi-rs's lack of native JSON passthrough) into the public shape.
-let parseDecoded = (
-  d: SvmHyperSyncClient.ResponseTypes.decodedInstruction,
-): Envio.svmInstructionParams => {
-  let args = try JSON.parseOrThrow(d.argsJson) catch {
+let parseArgs = (d: SvmHyperSyncClient.ResponseTypes.decodedInstruction): JSON.t =>
+  try JSON.parseOrThrow(d.argsJson) catch {
   | _ => JSON.Object(Dict.make())
   }
-  let accounts = try {
-    JSON.parseOrThrow(d.accountsJson)->(Utils.magic: JSON.t => dict<string>)
-  } catch {
-  | _ => Dict.make()
+
+let namedAccounts = (
+  ~idlNames: array<string>,
+  ~accountArguments: array<string>,
+): dict<Envio.svmInstructionAccount> => {
+  let out = Dict.make()
+  idlNames->Array.forEachWithIndex((name, i) =>
+    switch accountArguments->Array.get(i) {
+    | Some(address) =>
+      out->Dict.set(
+        name,
+        {
+          Envio.address: address->SvmTypes.Pubkey.fromStringUnsafe,
+          accountName: name,
+          instructionAccountIndex: i,
+        },
+      )
+    | None => ()
+    }
+  )
+  out
+}
+
+let selectedLog = (log: SvmHyperSyncClient.EventItems.log, ~logFields: Utils.Set.t<string>): Envio.svmLog => {
+  let out = Dict.make()
+  if logFields->Utils.Set.has("kind") {
+    switch log.kind {
+    | Some(kind) => out->Dict.set("kind", kind)
+    | None => ()
+    }
   }
-  {
-    name: d.name,
-    args,
-    accounts,
-    extraAccounts: d.extraAccounts,
+  if logFields->Utils.Set.has("message") {
+    switch log.message {
+    | Some(message) => out->Dict.set("message", message)
+    | None => ()
+    }
   }
+  out->(Utils.magic: dict<string> => Envio.svmLog)
 }
 
-// `block` is omitted; it's materialised from the block store at batch prep.
+let setField = (out: dict<unknown>, name: string, value: 'a) =>
+  out->Dict.set(name, value->(Utils.magic: 'a => unknown))
+
+// `block` and `transaction` are omitted; they're materialised from the stores
+// at batch prep. Named-account `.activity` is attached then too.
+// Unselected instruction keys must be omitted, not assigned `undefined`.
 let toSvmInstruction = (
   item: SvmHyperSyncClient.EventItems.item,
   ~programName,
   ~instructionName,
+  ~eventConfig: Internal.svmInstructionEventConfig,
+  ~fieldSelection: Internal.fieldSelection,
 ): Envio.svmInstruction => {
-  programName,
-  instructionName,
-  programId: item.programId->SvmTypes.Pubkey.fromStringUnsafe,
-  data: item.data,
-  accounts: item.accounts->SvmTypes.Pubkey.fromStringsUnsafe,
-  instructionAddress: item.instructionAddress,
-  isInner: item.isInner,
-  d1: ?item.d1,
-  d2: ?item.d2,
-  d4: ?item.d4,
-  d8: ?item.d8,
-  params: ?(item.decoded->Option.map(parseDecoded)),
-  logs: ?(
-    item.logs->Option.map(logs =>
-      logs->Array.map((log): Envio.svmLog => {kind: log.kind, message: log.message})
+  let hasSelection = name => fieldSelection.instructionFields->Utils.Set.has(name)
+  let discriminator = switch eventConfig.discriminator {
+  | Some(d) => d
+  | None => item.data
+  }
+  let out = Dict.make()
+  out->setField("programName", programName)
+  out->setField("instructionName", instructionName)
+  out->setField("discriminator", discriminator)
+  if hasSelection("programId") {
+    out->setField("programId", item.programId->SvmTypes.Pubkey.fromStringUnsafe)
+  }
+  if hasSelection("data") {
+    out->setField("data", item.data)
+  }
+  if hasSelection("path") {
+    out->setField("path", item.path)
+  }
+  if hasSelection("isInner") {
+    out->setField("isInner", item.isInner)
+  }
+  if hasSelection("args") {
+    out->setField("args", item.decoded->Option.map(parseArgs))
+  }
+  if hasSelection("accounts") {
+    out->setField(
+      "accounts",
+      namedAccounts(~idlNames=eventConfig.accounts, ~accountArguments=item.accounts),
     )
-  ),
+  }
+  if hasSelection("accountArguments") {
+    out->setField("accountArguments", item.accounts->SvmTypes.Pubkey.fromStringsUnsafe)
+  }
+  if fieldSelection.logFields->Utils.Set.size > 0 {
+    out->setField(
+      "logs",
+      item.logs
+      ->Option.getOr([])
+      ->Array.map(log => selectedLog(log, ~logFields=fieldSelection.logFields)),
+    )
+  }
+  out->(Utils.magic: dict<unknown> => Envio.svmInstruction)
 }
 
 let make = (
@@ -144,18 +199,20 @@ let make = (
         item,
         ~programName=eventConfig.contractName,
         ~instructionName=eventConfig.name,
+        ~eventConfig,
+        ~fieldSelection=onEventRegistration.fieldSelection,
       )
       Internal.Event({
         onEventRegistration,
         chainId,
         blockNumber: item.slot,
-        // A slot orders by `(transactionIndex, instructionAddress)` — the
+        // A slot orders by `(transactionIndex, path)` — the
         // transaction, then the instruction's position in its CPI tree. Both
         // ride the item so the buffer comparator can order on the pair
         // directly; no single integer can hold it (Solana allows a CPI depth
         // of 5, which needs more bits than a JS integer is exact to).
         logIndex: item.transactionIndex,
-        orderPath: item.instructionAddress,
+        orderPath: item.path,
         // The parent transaction is materialised from the store at batch prep.
         transactionIndex: item.transactionIndex,
         payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),