envio 3.6.1 → 3.7.0

package/src/ChainState.res.mjs

@@ -18,7 +18,6 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 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 ReorgDetection from "./ReorgDetection.res.mjs";
 import * as SimulateSource from "./sources/SimulateSource.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
@@ -50,7 +49,7 @@ function validateOnEventRegistrations(chainId, registrations) {
   });
 }
 
-function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, reorgThresholdReadyToleranceOpt, perChainEntitiesOpt, logger) {
+function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, sourceManager, committedProgressBlockNumber, safeCheckpointTrackingOpt, shouldRollbackOnReorg, maxReorgDepth, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, reorgThresholdReadyToleranceOpt, perChainEntitiesOpt, logger) {
   let onEventRegistrations = onEventRegistrationsOpt !== undefined ? onEventRegistrationsOpt : [];
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
@@ -77,8 +76,9 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
     pendingBudget: 0,
     chainDensity: chainDensity,
     entities: EntityTables.make(perChainEntities),
-    reorgDetection: reorgDetection,
     safeCheckpointTracking: safeCheckpointTracking,
+    shouldRollbackOnReorg: shouldRollbackOnReorg,
+    maxReorgDepth: maxReorgDepth,
     transactionStore: transactionStore,
     blockStore: blockStore,
     reorgThresholdReadyTolerance: reorgThresholdReadyTolerance,
@@ -132,7 +132,7 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       tmp = undefined;
       break;
   }
-  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, addressStore, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, match.onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock), Primitive_option.some(tmp), isResumed);
+  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, addressStore, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, match.onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock), Primitive_option.some(tmp), isResumed);
   let chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
     if (reorgCheckpoint.chain_id === chainConfig.id) {
       return reorgCheckpoint;
@@ -181,15 +181,23 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
         );
       break;
     case "SimulateSourceConfig" :
-      sources$1 = [SimulateSource.make(sources.items, sources.endBlock, chainId, addressStore)];
+      sources$1 = [SimulateSource.make(sources.items, sources.endBlock, chainId, addressStore, config.ecosystem.name)];
       break;
     case "CustomSources" :
       sources$1 = sources._0;
       break;
   }
+  let blockStore = BlockStore.make(config.ecosystem.name, !lowercaseAddresses);
+  if (Utils.$$Array.notEmpty(chainReorgCheckpoints)) {
+    let seedPage = BlockStore.fromJs(chainReorgCheckpoints.map(cp => ({
+      blockNumber: cp.block_number,
+      blockHash: cp.block_hash
+    })), config.ecosystem.name, !lowercaseAddresses);
+    blockStore.merge(seedPage, 0, false);
+  }
   let firstEventBlock$1 = fetchState.firstEventBlock;
   let chainDensity = firstEventBlock$1 !== undefined && progressBlockNumber > firstEventBlock$1 && numEventsProcessed > 0 ? numEventsProcessed / (progressBlockNumber - firstEventBlock$1 | 0) : undefined;
-  return make(chainConfig, fetchState, onEventRegistrations, addressStore, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(TransactionStore.make(config.ecosystem.name, !lowercaseAddresses)), Primitive_option.some(chainDensity), Primitive_option.some(BlockStore.make(config.ecosystem.name, !lowercaseAddresses)), config.reorgThresholdReadyTolerance, EntityTables.perChain(config.allEntities), logger);
+  return make(chainConfig, fetchState, onEventRegistrations, addressStore, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), config.shouldRollbackOnReorg, maxReorgDepth, numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(TransactionStore.make(config.ecosystem.name, !lowercaseAddresses)), Primitive_option.some(chainDensity), Primitive_option.some(blockStore), config.reorgThresholdReadyTolerance, EntityTables.perChain(config.allEntities), logger);
 }
 
 function makeFromConfig(chainConfig, config, registrationsByChainId, knownHeight) {
@@ -212,6 +220,10 @@ function logger(cs) {
   return cs.logger;
 }
 
+function blockStore(cs) {
+  return cs.blockStore;
+}
+
 function entities(cs) {
   return cs.entities;
 }
@@ -228,8 +240,16 @@ function chainConfig(cs) {
   return cs.chainConfig;
 }
 
-function reorgDetection(cs) {
-  return cs.reorgDetection;
+function shouldRollbackOnReorg(cs) {
+  return cs.shouldRollbackOnReorg;
+}
+
+function getReorgThresholdBlockNumbersBelow(cs, blockNumber) {
+  return cs.blockStore.getHashedBlockNumbers(Primitive_int.max(cs.fetchState.knownHeight - cs.maxReorgDepth | 0, 0), blockNumber);
+}
+
+function getLatestValidScannedBlock(cs, blockStore, blockNumbers) {
+  return Primitive_option.fromNull(cs.blockStore.latestValidBlockFromStore(blockStore, blockNumbers));
 }
 
 function safeCheckpointTracking(cs) {
@@ -447,7 +467,7 @@ function isDurablyCaughtUp(cs) {
 }
 
 function getHighestBlockBelowThreshold(cs) {
-  let highestBlockBelowThreshold = cs.fetchState.knownHeight - cs.chainConfig.maxReorgDepth | 0;
+  let highestBlockBelowThreshold = cs.fetchState.knownHeight - cs.maxReorgDepth | 0;
   if (highestBlockBelowThreshold < 0) {
     return 0;
   } else {
@@ -471,7 +491,7 @@ function isAtHeadWithoutEndBlock(cs) {
   }
 }
 
-function groupBatchItems(items, includeBlocks) {
+function groupBatchItems(items) {
   let txBlockNumbers = [];
   let transactionIndices = [];
   let transactionMasks = [];
@@ -490,7 +510,7 @@ function groupBatchItems(items, includeBlocks) {
     let match = item.payload.transaction;
     if (match == null) {
       let transactionIndex = item.transactionIndex;
-      let mask = item.onEventRegistration.eventConfig.transactionFieldMask;
+      let mask = item.onEventRegistration.fieldSelection.transactionMask;
       if (mask !== 0) {
         anyTransactionFieldSelected.contents = true;
       }
@@ -505,14 +525,11 @@ function groupBatchItems(items, includeBlocks) {
         payloadGroups.push([item.payload]);
       }
     }
-    if (!includeBlocks) {
-      return;
-    }
     let match$1 = item.payload.block;
     if (!(match$1 == null)) {
       return;
     }
-    let mask$1 = item.onEventRegistration.eventConfig.blockFieldMask;
+    let mask$1 = item.onEventRegistration.fieldSelection.blockMask;
     let last$1 = blockItemGroups.length - 1 | 0;
     if (last$1 >= 0 && blockBlockNumbers[last$1] === blockNumber) {
       blockItemGroups[last$1].push(item);
@@ -573,48 +590,50 @@ async function applyBlockGroups(store, g) {
   });
 }
 
-function includeBlocksForEcosystem(ecosystem) {
-  switch (ecosystem) {
-    case "fuel" :
-      return false;
-    case "evm" :
-    case "svm" :
-      return true;
-  }
-}
-
-async function materializeBatchItems(cs, items, ecosystem) {
-  let match = groupBatchItems(items, includeBlocksForEcosystem(ecosystem));
+async function materializeBatchItems(cs, items) {
+  let match = groupBatchItems(items);
   await Promise.all([
     applyTransactionGroups(cs.transactionStore, match[0]),
     applyBlockGroups(cs.blockStore, match[1])
   ]);
 }
 
-async function materializePageItems(items, transactionStore, blockStore, ecosystem) {
-  let match = groupBatchItems(items, includeBlocksForEcosystem(ecosystem));
+async function materializePageItems(items, transactionStore, blockStore) {
+  let match = groupBatchItems(items);
   await Promise.all([
     transactionStore !== undefined ? applyTransactionGroups(Primitive_option.valFromOption(transactionStore), match[0]) : Promise.resolve(),
-    blockStore !== undefined ? applyBlockGroups(Primitive_option.valFromOption(blockStore), match[1]) : Promise.resolve()
+    applyBlockGroups(blockStore, match[1])
   ]);
 }
 
-function handleQueryResult(cs, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, txPage, blockPage) {
+function handleQueryResult(cs, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, txPage) {
   if (txPage !== undefined) {
     cs.transactionStore.merge(Primitive_option.valFromOption(txPage));
   }
-  if (blockPage !== undefined) {
-    cs.blockStore.merge(Primitive_option.valFromOption(blockPage));
-  }
-  let fs = newRegistrations.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock.blockNumber), newRegistrations) : cs.fetchState;
+  let fs = newRegistrations.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock), newRegistrations) : cs.fetchState;
   cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.itemsEst);
 }
 
-function registerReorgGuard(cs, blockHashes, knownHeight) {
-  let match = ReorgDetection.registerReorgGuard(cs.reorgDetection, blockHashes, knownHeight);
-  cs.reorgDetection = match[0];
-  return match[1];
+function registerReorgGuard(cs, blockStore, knownHeight) {
+  let match = cs.blockStore.merge(blockStore, Primitive_int.max(knownHeight - cs.maxReorgDepth | 0, 0), !cs.shouldRollbackOnReorg);
+  if (match === null) {
+    return "NoReorg";
+  }
+  let blockNumber = match.blockNumber;
+  return {
+    TAG: "ReorgDetected",
+    _0: {
+      scannedBlock: {
+        blockHash: match.storedHash,
+        blockNumber: blockNumber
+      },
+      receivedBlock: {
+        blockHash: match.receivedHash,
+        blockNumber: blockNumber
+      }
+    }
+  };
 }
 
 function prepareReorg(cs, eventsProcessedDiff) {
@@ -720,9 +739,20 @@ function toMetrics(cs) {
 }
 
 function toChainBeforeBatch(cs) {
+  let match = cs.blockStore.getHashes(Primitive_int.max(cs.fetchState.knownHeight - cs.maxReorgDepth | 0, 0), cs.fetchState.knownHeight + 1 | 0);
+  let hashes = match.hashes;
+  let blockNumbers = match.blockNumbers;
+  let hashByBlockNumber = {};
+  blockNumbers.forEach((blockNumber, idx) => {
+    hashByBlockNumber[blockNumber] = hashes[idx];
+  });
   return {
     fetchState: cs.fetchState,
-    reorgDetection: cs.reorgDetection,
+    scannedHashes: {
+      blockNumbers: blockNumbers,
+      hashByBlockNumber: hashByBlockNumber
+    },
+    shouldRollbackOnReorg: cs.shouldRollbackOnReorg,
     progressBlockNumber: cs.committedProgressBlockNumber,
     sourceBlockNumber: cs.fetchState.knownHeight,
     totalEventsProcessed: cs.numEventsProcessed,
@@ -804,7 +834,7 @@ function applyBatchProgress(cs, batch, blockTimestampName) {
   cs.processingBlockNumber = Primitive_int.max(cs.processingBlockNumber, chainAfterBatch.progressBlockNumber);
   cs.numEventsProcessed = chainAfterBatch.totalEventsProcessed;
   cs.transactionStore.prune(chainAfterBatch.progressBlockNumber);
-  cs.blockStore.prune(chainAfterBatch.progressBlockNumber);
+  cs.blockStore.prune(chainAfterBatch.progressBlockNumber, cs.fetchState.knownHeight - cs.maxReorgDepth | 0);
   cs.isProgressAtHead = cs.isProgressAtHead || chainAfterBatch.isProgressAtHeadWhenBatchCreated;
   let safeCheckpointTracking = cs.safeCheckpointTracking;
   if (safeCheckpointTracking !== undefined) {
@@ -823,7 +853,6 @@ function markReady(cs, readyAt) {
 function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTargetBlockNumber, isReorgChain) {
   if (newProgressBlockNumber === undefined) {
     if (isReorgChain) {
-      cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
       cs.fetchState = FetchState.rollback(cs.fetchState, cs.addressStore, rollbackTargetBlockNumber);
       cs.transactionStore.rollback(rollbackTargetBlockNumber);
       cs.blockStore.rollback(rollbackTargetBlockNumber);
@@ -835,9 +864,6 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
     }
   }
   let newTotalEventsProcessed = cs.numEventsProcessed - Stdlib_Option.getOrThrow(eventsProcessedDiff, "Missing events-processed diff for rolled-back chain");
-  if (isReorgChain) {
-    cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
-  }
   let safeCheckpointTracking = cs.safeCheckpointTracking;
   if (safeCheckpointTracking !== undefined) {
     cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
@@ -856,11 +882,14 @@ export {
   makeFromConfig,
   makeFromDbState,
   logger,
+  blockStore,
   entities,
   resetEntities,
   sourceManager,
   chainConfig,
-  reorgDetection,
+  shouldRollbackOnReorg,
+  getReorgThresholdBlockNumbersBelow,
+  getLatestValidScannedBlock,
   safeCheckpointTracking,
   isProgressAtHead,
   committedProgressBlockNumber,

package/src/ChainState.resi

@@ -11,9 +11,10 @@ let make: (
   ~onEventRegistrations: array<Internal.onEventRegistration>=?,
   ~addressStore: AddressStore.t,
   ~sourceManager: SourceManager.t,
-  ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
   ~safeCheckpointTracking: option<SafeCheckpointTracking.t>=?,
+  ~shouldRollbackOnReorg: bool,
+  ~maxReorgDepth: int,
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
@@ -45,11 +46,19 @@ let makeFromDbState: (
 
 // Accessors.
 let logger: t => Pino.t
+let blockStore: t => BlockStore.t
 let entities: t => EntityTables.t
 let resetEntities: (t, ~perChainEntities: array<Internal.entityConfig>) => unit
 let sourceManager: t => SourceManager.t
 let chainConfig: t => Config.chain
-let reorgDetection: t => ReorgDetection.t
+let shouldRollbackOnReorg: t => bool
+// Reorg-scan reads over the chain's block store, for the rollback flow.
+let getReorgThresholdBlockNumbersBelow: (t, ~blockNumber: int) => array<int>
+let getLatestValidScannedBlock: (
+  t,
+  ~blockStore: BlockStore.t,
+  ~blockNumbers: array<int>,
+) => option<int>
 let safeCheckpointTracking: t => option<SafeCheckpointTracking.t>
 let isProgressAtHead: t => bool
 let committedProgressBlockNumber: t => int
@@ -120,25 +129,19 @@ let handleQueryResult: (
   ~query: FetchState.query,
   ~newItems: array<Internal.item>,
   ~newRegistrations: array<AddressStore.registration>,
-  ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
+  ~latestFetchedBlock: int,
   ~knownHeight: int,
   ~transactionStore: option<TransactionStore.t>,
-  ~blockStore: option<BlockStore.t>,
 ) => unit
-let materializeBatchItems: (
-  t,
-  ~items: array<Internal.item>,
-  ~ecosystem: Ecosystem.name,
-) => promise<unit>
+let materializeBatchItems: (t, ~items: array<Internal.item>) => promise<unit>
 let materializePageItems: (
   ~items: array<Internal.item>,
   ~transactionStore: option<TransactionStore.t>,
-  ~blockStore: option<BlockStore.t>,
-  ~ecosystem: Ecosystem.name,
+  ~blockStore: BlockStore.t,
 ) => promise<unit>
 let registerReorgGuard: (
   t,
-  ~blockHashes: array<ReorgDetection.blockData>,
+  ~blockStore: BlockStore.t,
   ~knownHeight: int,
 ) => ReorgDetection.reorgResult
 let prepareReorg: (t, ~eventsProcessedDiff: option<float>) => unit

package/src/Config.res

@@ -1016,8 +1016,15 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
         | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
-
-        | Ecosystem.Fuel | Ecosystem.Svm => 0
+        // Tower BFT roots a block once 32 votes lock it in (MAX_LOCKOUT_HISTORY
+        // is 31, plus the slot itself), which is what `finalized` waits for — so
+        // 32 is the protocol's own bound on how far a fork can be replaced. That
+        // bound counts *blocks* while the threshold here is measured in slot
+        // numbers, and skipped slots make the slot distance the larger of the
+        // two, so the default keeps a wide margin over it. Slots are ~0.4s, so
+        // even this spans well under two minutes of chain.
+        | Ecosystem.Svm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+        | Ecosystem.Fuel => 0
         },
         blockLag: publicChainConfig["blockLag"]->Option.getOr(0),
         contracts,

package/src/Config.res.mjs

@@ -685,13 +685,13 @@ function fromPublic(publicConfigJson) {
     }
     let tmp;
     switch (ecosystemName) {
-      case "evm" :
-        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 200);
-        break;
       case "fuel" :
-      case "svm" :
         tmp = 0;
         break;
+      case "evm" :
+      case "svm" :
+        tmp = Stdlib_Option.getOr(publicChainConfig.maxReorgDepth, 200);
+        break;
     }
     return {
       name: chainName,

package/src/Core.res

@@ -11,6 +11,8 @@ type fuelHyperSyncClientCtor
 type transactionStoreCtor
 type blockStoreCtor
 type addressStoreCtor
+// Test-only: a local HyperSync server, bound by MockHyperSyncServer in envio-tests.
+type mockHyperSyncServerCtor
 type fromUserApiOptions = {
   schema?: string,
   env?: dict<string>,
@@ -43,6 +45,8 @@ type addon = {
   blockStore: blockStoreCtor,
   @as("AddressStore")
   addressStore: addressStoreCtor,
+  @as("MockHyperSyncServer")
+  mockHyperSyncServer: mockHyperSyncServerCtor,
   // Ordered transaction-field names exposed for the field-code contract test
   // (the ReScript `transactionFields` arrays must match the Rust ordinals).
   evmTransactionFieldNames: unit => array<string>,
@@ -51,6 +55,7 @@ type addon = {
   // must match the Rust ordinals).
   evmBlockFieldNames: unit => array<string>,
   svmBlockFieldNames: unit => array<string>,
+  fuelBlockFieldNames: unit => array<string>,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/Ecosystem.res

@@ -5,7 +5,6 @@ type t = {
   blockNumberName: string,
   blockTimestampName: string,
   blockHashName: string,
-  cleanUpRawEventFieldsInPlace: JSON.t => unit,
   /** Method name that the block handler is exposed under on the public
       `indexer` object — `"onBlock"` for chain-based ecosystems, `"onSlot"`
       for SVM. Centralised here so adding a new ecosystem only requires a

package/src/Envio.res

@@ -42,14 +42,24 @@ type svmInstructionParams = {
 type svmTokenBalance = {
   account?: SvmTypes.Pubkey.t,
   mint?: SvmTypes.Pubkey.t,
+  /** Owner at the end of the transaction, falling back to the owner on entry
+   when the account was closed during it. Pre and post owners differ only when
+   a `SetAuthority(AccountOwner)` runs mid-transaction. */
   owner?: SvmTypes.Pubkey.t,
-  preAmount?: string,
-  postAmount?: string,
+  /** Mint decimals, for scaling the raw amounts below. */
+  decimals?: int,
+  /** Raw amount in base units before the transaction. Absent when the token
+   account was created during it. */
+  preAmount?: bigint,
+  /** Raw amount in base units after the transaction. Absent when the token
+   account was closed during it. */
+  postAmount?: bigint,
 }
 
 type svmTransaction = {
   transactionIndex?: int,
-  signatures: array<string>,
+  /** The transaction's identifying signature (`allSignatures[0]`). */
+  signature: string,
   feePayer?: SvmTypes.Pubkey.t,
   success?: bool,
   err?: string,
@@ -58,6 +68,9 @@ type svmTransaction = {
   accountKeys: array<SvmTypes.Pubkey.t>,
   recentBlockhash?: string,
   version?: string,
+  /** Every signature on the transaction, in message order; the first is
+   `signature`. Longer than one element only for a multi-signer transaction. */
+  allSignatures: array<string>,
   tokenBalances?: array<svmTokenBalance>,
 }