envio 3.7.0 → 3.9.0

package/src/Config.res.mjs

@@ -16,6 +16,7 @@ import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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 ContractMapping from "./ContractMapping.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -32,57 +33,6 @@ function chainIdColumnName(format) {
   }
 }
 
-let name = "envio_addresses";
-
-function makeId(chainId, address) {
-  return ChainId.toString(chainId) + "-" + address;
-}
-
-function getAddress(entity) {
-  let sepIdx = entity.id.indexOf("-");
-  return entity.id.slice(sepIdx + 1 | 0, entity.id.length);
-}
-
-let schema = S$RescriptSchema.schema(s => ({
-  id: s.m(S$RescriptSchema.string),
-  chain_id: s.m(ChainId.schema),
-  registration_block: s.m(S$RescriptSchema.int),
-  registration_log_index: s.m(S$RescriptSchema.int),
-  contract_name: s.m(S$RescriptSchema.string)
-}));
-
-let table = Table.mkTable(name, undefined, [
-  Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_log_index", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
-], undefined);
-
-let entityConfig_storage = {
-  postgres: true,
-  clickhouse: false
-};
-
-let entityConfig = {
-  name: name,
-  index: -1,
-  schema: schema,
-  table: table,
-  storage: entityConfig_storage,
-  crossChain: true
-};
-
-let EnvioAddresses = {
-  name: name,
-  index: -1,
-  makeId: makeId,
-  getAddress: getAddress,
-  schema: schema,
-  table: table,
-  entityConfig: entityConfig
-};
-
 let rpcSourceForSchema = S$RescriptSchema.$$enum([
   "sync",
   "fallback",
@@ -124,9 +74,6 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   discriminatorByteLen: s.m(S$RescriptSchema.int),
-  transactionFields: s.m(S$RescriptSchema.array(Internal.svmTransactionFieldSchema)),
-  blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.svmBlockFieldSchema))),
-  includeLogs: s.m(S$RescriptSchema.bool),
   accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
     position: s.m(S$RescriptSchema.int),
     values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
@@ -204,10 +151,18 @@ let propertySchema = S$RescriptSchema.schema(s => ({
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string))
 }));
 
+let clickhouseSkippingIndexSchema = S$RescriptSchema.object(s => ({
+  name: s.f("name", S$RescriptSchema.string),
+  expr: s.f("expr", S$RescriptSchema.string),
+  type: s.f("type", S$RescriptSchema.string),
+  granularity: s.f("granularity", S$RescriptSchema.option(S$RescriptSchema.int))
+}));
+
 let clickhouseTableOptionsSchema = S$RescriptSchema.object(s => ({
   partitionBy: s.f("partitionBy", S$RescriptSchema.option(S$RescriptSchema.string)),
   orderBy: s.f("orderBy", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
-  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string))
+  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string)),
+  skippingIndexes: s.f("skippingIndexes", S$RescriptSchema.option(S$RescriptSchema.array(clickhouseSkippingIndexSchema)))
 }));
 
 let entityClickhouseStorageJsonSchema = S$RescriptSchema.union([
@@ -230,6 +185,7 @@ let entityJsonSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
   crossChain: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   storage: s.m(S$RescriptSchema.option(entityStorageSchema)),
+  internal: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   properties: s.m(S$RescriptSchema.array(propertySchema)),
   derivedFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(derivedFieldSchema))),
   compositeIndices: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(compositeIndexFieldSchema)))),
@@ -400,7 +356,8 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage, d
       schema: schema,
       table: table,
       storage: storage,
-      crossChain: crossChain
+      crossChain: crossChain,
+      internal: Stdlib_Option.getOr(entityJson.internal, false)
     };
   });
 }
@@ -436,6 +393,16 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema)))
 }));
 
+function contractMappingOf(chainConfigs) {
+  let names = [];
+  chainConfigs.forEach(chain => {
+    chain.contracts.forEach(contract => {
+      names.push(contract.name);
+    });
+  });
+  return ContractMapping.make(names);
+}
+
 function fromPublic(publicConfigJson) {
   let publicConfig;
   try {
@@ -564,7 +531,7 @@ function fromPublic(publicConfigJson) {
               position: af.position,
               values: af.values
             })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, svm.blockFields, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
         }
       });
     } else {
@@ -614,16 +581,14 @@ function fromPublic(publicConfigJson) {
         startBlock: startBlock
       };
     });
-    let contractNameByAddress = {};
+    let seen = new Set();
     contracts.forEach(contract => {
       contract.addresses.forEach(address => {
-        let existingContractName = contractNameByAddress[address];
-        if (existingContractName !== undefined) {
-          return Stdlib_JsError.throwWithMessage(existingContractName === contract.name ? `Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + ChainId.toString(chainId) + `. Please remove the duplicate from your config.` : `Address ` + address + ` on chain ` + ChainId.toString(chainId) + ` is configured for multiple contracts: ` + existingContractName + ` and ` + contract.name + `. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`);
-        } else {
-          contractNameByAddress[address] = contract.name;
-          return;
+        let key = contract.name + "-" + address;
+        if (seen.has(key)) {
+          Stdlib_JsError.throwWithMessage(`Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + ChainId.toString(chainId) + `. Please remove the duplicate from your config.`);
         }
+        seen.add(key);
       });
     });
     let sourceConfig;
@@ -696,6 +661,7 @@ function fromPublic(publicConfigJson) {
     return {
       name: chainName,
       id: chainId,
+      ecosystem: ecosystemName,
       startBlock: publicChainConfig.startBlock,
       endBlock: publicChainConfig.endBlock,
       maxReorgDepth: tmp,
@@ -725,7 +691,6 @@ function fromPublic(publicConfigJson) {
   };
   let defaultCrossChain = Stdlib_Option.getOr(publicConfig.defaultCrossChain, true);
   let userEntities = parseEntitiesFromJson(Stdlib_Option.getOr(publicConfig.entities, []), enumConfigsByName, globalStorage, defaultCrossChain);
-  let allEntities = userEntities.concat([entityConfig]);
   let userEntitiesByName = Object.fromEntries(userEntities.map(entityConfig => [
     Utils.$$String.capitalize(entityConfig.name),
     entityConfig
@@ -745,6 +710,7 @@ function fromPublic(publicConfigJson) {
     storage: globalStorage,
     chainIdMode: Stdlib_Option.getOr(publicConfig.chainIdMode, "int32"),
     chainMap: chainMap,
+    contractMapping: contractMappingOf(chains),
     defaultChain: chains[0],
     ecosystem: ecosystem,
     enableRawEvents: Stdlib_Option.getOr(publicConfig.rawEvents, false),
@@ -756,7 +722,6 @@ function fromPublic(publicConfigJson) {
     isDev: Stdlib_Option.getOr(publicConfig.isDev, false),
     userEntitiesByName: userEntitiesByName,
     userEntities: userEntities,
-    allEntities: allEntities,
     allEnums: allEnums
   };
 }
@@ -1083,7 +1048,6 @@ function getPgUserEntities(config) {
 export {
   chainIdFieldName,
   chainIdColumnName,
-  EnvioAddresses,
   rpcSourceForSchema,
   rpcConfigSchema,
   chainContractSchema,
@@ -1097,6 +1061,7 @@ export {
   compositeIndexFieldSchema,
   derivedFieldSchema,
   propertySchema,
+  clickhouseSkippingIndexSchema,
   clickhouseTableOptionsSchema,
   entityClickhouseStorageJsonSchema,
   entityStorageSchema,
@@ -1108,6 +1073,7 @@ export {
   columnNameFormatSchema,
   publicConfigStorageSchema,
   publicConfigSchema,
+  contractMappingOf,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
@@ -1124,4 +1090,4 @@ export {
   load,
   getPgUserEntities,
 }
-/* schema Not a pure module */
+/* rpcSourceForSchema Not a pure module */

package/src/ContractMapping.res

@@ -0,0 +1,66 @@
+// The contract name <-> id mapping every stored address row references: a
+// name's position in `names` is the id `envio_contracts` holds and
+// `envio_addresses.contract_id` points at. Ids must mean the same thing on
+// every chain and across restarts, so a mapping is built once — from the whole
+// config, never from a filtered subset — and read everywhere else.
+type t = {
+  // Id order. Index i is the name of contract id i.
+  names: array<string>,
+  idByName: dict<int>,
+}
+
+let indexNames = (names: array<string>): t => {
+  let idByName = Dict.make()
+  names->Array.forEachWithIndex((name, id) => idByName->Dict.set(name, id))
+  {names, idByName}
+}
+
+// Ids are 0-based positions in a smallint column, so 32768 contracts fit.
+let maxContracts = 32768
+
+// Names in any order; the codec puts them in byte order so the ids never depend
+// on the order contracts happen to be declared in.
+let make = (~names: array<string>): t => {
+  let canonical = Core.getAddon().canonicalContractNames(names)
+  if canonical->Array.length > maxContracts {
+    JsError.throwWithMessage(
+      `The indexer declares ${canonical
+        ->Array.length
+        ->Int.toString} contracts, more than the ${maxContracts->Int.toString} a smallint contract id can hold.`,
+    )
+  }
+  indexNames(canonical)
+}
+
+// What a storage holds before it has been initialized: no contract has an id
+// yet, so every lookup fails rather than resolving against a stale mapping.
+let empty = indexNames([])
+
+// A mapping read back from storage. Taken verbatim: the stored order *is* the
+// id order the stored rows were written against, so re-canonicalizing it would
+// paper over a mapping that no longer matches those rows.
+let fromStoredNames = indexNames
+
+let names = (mapping: t) => mapping.names
+
+let idOfOrThrow = (mapping: t, name, ~context="") =>
+  switch mapping.idByName->Utils.Dict.dangerouslyGetNonOption(name) {
+  | Some(id) => id
+  | None =>
+    JsError.throwWithMessage(
+      `Contract "${name}"${context} is missing from the indexer's contract list.`,
+    )
+  }
+
+let nameOfOrThrow = (mapping: t, id) =>
+  switch mapping.names->Array.get(id) {
+  | Some(name) => name
+  | None =>
+    JsError.throwWithMessage(
+      `Contract id ${id->Int.toString} is outside the indexer's contract list.`,
+    )
+  }
+
+let isEqual = (a: t, b: t) =>
+  a.names->Array.length === b.names->Array.length &&
+    a.names->Array.everyWithIndex((name, idx) => b.names->Array.getUnsafe(idx) === name)

package/src/ContractMapping.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "./Core.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function indexNames(names) {
+  let idByName = {};
+  names.forEach((name, id) => {
+    idByName[name] = id;
+  });
+  return {
+    names: names,
+    idByName: idByName
+  };
+}
+
+function make(names) {
+  let canonical = Core.getAddon().canonicalContractNames(names);
+  if (canonical.length > 32768) {
+    Stdlib_JsError.throwWithMessage(`The indexer declares ` + canonical.length.toString() + ` contracts, more than the ` + (32768).toString() + ` a smallint contract id can hold.`);
+  }
+  return indexNames(canonical);
+}
+
+let empty = indexNames([]);
+
+function names(mapping) {
+  return mapping.names;
+}
+
+function idOfOrThrow(mapping, name, contextOpt) {
+  let context = contextOpt !== undefined ? contextOpt : "";
+  let id = mapping.idByName[name];
+  if (id !== undefined) {
+    return id;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Contract "` + name + `"` + context + ` is missing from the indexer's contract list.`);
+  }
+}
+
+function nameOfOrThrow(mapping, id) {
+  let name = mapping.names[id];
+  if (name !== undefined) {
+    return name;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Contract id ` + id.toString() + ` is outside the indexer's contract list.`);
+  }
+}
+
+function isEqual(a, b) {
+  if (a.names.length === b.names.length) {
+    return a.names.every((name, idx) => b.names[idx] === name);
+  } else {
+    return false;
+  }
+}
+
+let maxContracts = 32768;
+
+let fromStoredNames = indexNames;
+
+export {
+  indexNames,
+  maxContracts,
+  make,
+  empty,
+  fromStoredNames,
+  names,
+  idOfOrThrow,
+  nameOfOrThrow,
+  isEqual,
+}
+/* empty Not a pure module */

package/src/Core.res

@@ -47,6 +47,22 @@ type addon = {
   addressStore: addressStoreCtor,
   @as("MockHyperSyncServer")
   mockHyperSyncServer: mockHyperSyncServerCtor,
+  encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
+  renderAddresses: (
+    ~ecosystem: string,
+    ~shouldChecksum: bool,
+    ~bytes: NodeJs.Buffer.t,
+    ~lengths: array<int>,
+  ) => array<Address.t>,
+  renderContractAddresses: (
+    ~ecosystem: string,
+    ~shouldChecksum: bool,
+    ~bytes: NodeJs.Buffer.t,
+    ~lengths: array<int>,
+    ~contractIds: array<int>,
+    ~contractId: int,
+  ) => array<Address.t>,
+  canonicalContractNames: array<string> => array<string>,
   // Ordered transaction-field names exposed for the field-code contract test
   // (the ReScript `transactionFields` arrays must match the Rust ordinals).
   evmTransactionFieldNames: unit => array<string>,
@@ -84,6 +100,10 @@ let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
   var path = Nodepath;
   var fs = Nodefs;
 
+  // Vitest test.env points workers at the addon globalSetup already built.
+  var preBuilt = process.env.ENVIO_DEV_ADDON;
+  if (preBuilt && fs.existsSync(preBuilt)) return req(preBuilt);
+
   var repoRoot = null;
   var dir = path.resolve(envioDir);
   for (var i = 0; i < 10; i++) {

package/src/Core.res.mjs

@@ -26,6 +26,10 @@ let loadDevAddon = (function(req, envioDir) {
   var path = Nodepath;
   var fs = Nodefs;
 
+  // Vitest test.env points workers at the addon globalSetup already built.
+  var preBuilt = process.env.ENVIO_DEV_ADDON;
+  if (preBuilt && fs.existsSync(preBuilt)) return req(preBuilt);
+
   var repoRoot = null;
   var dir = path.resolve(envioDir);
   for (var i = 0; i < 10; i++) {

package/src/Envio.res

@@ -20,58 +20,48 @@ type svmOnSlotArgs<'context> = {
   context: 'context,
 }
 
-/** Borsh-decoded instruction view. Present whenever a `ProgramSchema` was
- attached to the program (bundled schema, Anchor IDL, or hand-written YAML
- `accounts`/`args`). Absent (`None`) when no schema applied or the
- discriminator didn't match any registered instruction. */
-type svmInstructionParams = {
-  /** Schema-declared instruction name (matches the codegen module suffix). */
-  name: string,
-  /** Borsh-decoded args. `JSON.Object({})` for no-arg instructions
-   (e.g. `VerifyCollection`). POC types this as raw `JSON.t`; cast at the
-   handler with `(json :> MyArgsType)` until typed codegen lands. */
-  args: JSON.t,
-  /** Named accounts in schema order. Keys are exactly the schema-declared
-   names; values are base58 pubkey strings. */
-  accounts: dict<string>,
-  /** Accounts beyond the schema's named list (Anchor `remaining_accounts`,
-   IDL drift). `[]` when counts match. */
-  extraAccounts: array<string>,
+type svmLamports = {
+  pre: bigint,
+  post: bigint,
 }
 
-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,
-  /** 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. */
+type svmAccountToken = {
+  mint: SvmTypes.Pubkey.t,
+  owner: SvmTypes.Pubkey.t,
+  decimals: int,
   preAmount?: bigint,
-  /** Raw amount in base units after the transaction. Absent when the token
-   account was closed during it. */
   postAmount?: bigint,
 }
 
+type svmAccountActivity = {
+  address: SvmTypes.Pubkey.t,
+  transactionAccountIndex?: int,
+  isSigner?: bool,
+  isWritable?: bool,
+  lamports?: svmLamports,
+  token?: svmAccountToken,
+}
+
+type svmInstructionAccount = {
+  address: SvmTypes.Pubkey.t,
+  accountName: string,
+  instructionAccountIndex: int,
+  activity?: svmAccountActivity,
+}
+
 type svmTransaction = {
   transactionIndex?: int,
-  /** The transaction's identifying signature (`allSignatures[0]`). */
-  signature: string,
+  signature?: string,
   feePayer?: SvmTypes.Pubkey.t,
   success?: bool,
   err?: string,
   fee?: bigint,
   computeUnitsConsumed?: bigint,
-  accountKeys: array<SvmTypes.Pubkey.t>,
+  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>,
+  allSignatures?: array<string>,
+  accountActivities?: array<svmAccountActivity>,
 }
 
 type svmLog = {
@@ -79,57 +69,29 @@ type svmLog = {
   message: string,
 }
 
-/** Block context for a matched instruction. `slot`/`hash` are always present;
- `time` can still be absent — HyperSync/Solana may not report a block time for
- every slot. Every other field is opt-in via `field_selection.block_fields`,
- materialised from the per-chain block store at batch prep. */
-type svmInstructionBlock = {
-  /** Slot this instruction's block was matched in. */
+type svmBlock = {
   slot: int,
-  /** Unix block time (seconds). */
   time?: int,
-  hash: string,
-  /** Block height (distinct from slot). Absent when not selected via
-   `field_selection.block_fields`. */
+  hash?: string,
   height?: int,
   parentSlot?: int,
   parentHash?: string,
 }
 
-/** The per-instruction payload handlers receive as their `instruction`
- argument. Carries the matched instruction's own fields plus the
- program/instruction names, parent transaction, scoped logs, and block. */
 type svmInstruction = {
-  /** Program name as declared under `programs[].name` in `config.yaml`. */
   programName: string,
-  /** Instruction name as declared under `instructions[].name` in
-   `config.yaml`. */
   instructionName: string,
-  programId: SvmTypes.Pubkey.t,
-  /** Raw instruction bytes as `0x`-prefixed hex. */
-  data: string,
-  accounts: array<SvmTypes.Pubkey.t>,
-  /** Path through the call tree: `[outerIndex]` for top-level instructions,
-   appended child indices for inner CPI calls. */
-  instructionAddress: array<int>,
-  isInner: bool,
-  /** Discriminator prefixes pre-extracted by HyperSync. Each is `Some` only
-   when the underlying instruction is at least that long. */
-  d1?: string,
-  d2?: string,
-  d4?: string,
-  d8?: string,
-  /** Borsh-decoded params view. See [[svmInstructionParams]]. */
-  params?: svmInstructionParams,
-  /** Parent transaction. Carries only the fields selected via
-   `field_selection.transaction_fields`; absent when none are selected. */
+  discriminator: string,
+  programId?: SvmTypes.Pubkey.t,
+  data?: string,
+  path?: array<int>,
+  isInner?: bool,
+  args?: JSON.t,
+  accounts?: dict<svmInstructionAccount>,
+  accountArguments?: array<SvmTypes.Pubkey.t>,
   transaction?: svmTransaction,
-  /** Program log entries scoped to this instruction. Absent when the
-   per-instruction `include_logs` flag is `false`. */
   logs?: array<svmLog>,
-  // Omitted on construction; materialised onto the payload at batch prep,
-  // before a handler ever reads it.
-  block?: svmInstructionBlock,
+  block?: svmBlock,
 }
 
 /** Arguments passed to handlers registered via `indexer.onInstruction`. */
@@ -315,6 +277,22 @@ type fuelSimulateItem = {
   transaction?: fuelTransactionInput,
 }
 
+type svmSimulateItem = {
+  program: string,
+  instruction: string,
+  slot?: int,
+  path?: array<int>,
+  programId?: string,
+  data?: string,
+  isInner?: bool,
+  args?: JSON.t,
+  accounts?: dict<{address: string}>,
+  accountArguments?: array<string>,
+  logs?: array<{kind?: string, message?: string}>,
+  block?: svmBlock,
+  transaction?: unknown,
+}
+
 // Detects contexts where a full-screen TUI is counter-productive: piped/redirected
 // stdout, CI, and coding agents. `CLAUDECODE` is set by Claude Code; `CI` is the
 // de-facto convention across CI providers; `TERM=dumb` is set by editors/tools