@aztec/stdlib 3.0.0-nightly.20251114 → 3.0.0-nightly.20251115

package/src/messaging/in_hash.ts

@@ -0,0 +1,15 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeCalculator } from '@aztec/foundation/trees';
+
+/** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */
+export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Promise<Fr> {
+  const l1ToL2Messages = padArrayEnd<Fr, number>(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  const hasher = (left: Buffer, right: Buffer) =>
+    Promise.resolve(sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>);
+  const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+  const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
+  return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
+}

package/src/messaging/index.ts

@@ -1,3 +1,4 @@
+export * from './in_hash.js';
 export * from './inbox_leaf.js';
 export * from './l1_to_l2_message.js';
 export * from './l1_to_l2_message_source.js';
@@ -5,3 +6,4 @@ export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
 export * from './l2_to_l1_membership.js';
+export * from './out_hash.js';

package/src/messaging/out_hash.ts

@@ -0,0 +1,36 @@
+import { Fr } from '@aztec/foundation/fields';
+import { UnbalancedMerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
+
+export function computeTxOutHash(messages: Fr[]): Fr {
+  if (!messages.length) {
+    return Fr.ZERO;
+  }
+  // Tx out hash is the root of the unbalanced merkle tree of all the messages.
+  // Zero hashes (which should not happen) are not compressed.
+  return Fr.fromBuffer(computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer())));
+}
+
+export function computeBlockOutHash(messagesPerBlock: Fr[][]): Fr {
+  const txOutHashes = messagesPerBlock.map(messages => computeTxOutHash(messages));
+  return aggregateOutHashes(txOutHashes);
+}
+
+export function computeCheckpointOutHash(messagesForAllTxs: Fr[][][]): Fr {
+  const blockOutHashes = messagesForAllTxs.map(block => computeBlockOutHash(block));
+  return aggregateOutHashes(blockOutHashes);
+}
+
+// The root of this tree should match the `out_hash` calculated in the circuits. Zero hashes are compressed to reduce
+// cost if the non-zero leaves result in a shorter path.
+function aggregateOutHashes(outHashes: Fr[]): Fr {
+  if (!outHashes.length) {
+    return Fr.ZERO;
+  }
+
+  const valueToCompress = Buffer.alloc(32);
+  const tree = UnbalancedMerkleTreeCalculator.create(
+    outHashes.map(hash => hash.toBuffer()),
+    valueToCompress,
+  );
+  return Fr.fromBuffer(tree.getRoot());
+}

package/src/rollup/checkpoint_constant_data.ts

@@ -3,6 +3,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { inspect } from 'util';
+
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 
@@ -81,4 +83,22 @@ export class CheckpointConstantData {
       reader.readObject(GasFees),
     );
   }
+
+  toInspect() {
+    return {
+      chainId: this.chainId.toNumber(),
+      version: this.version.toNumber(),
+      vkTreeRoot: this.vkTreeRoot.toString(),
+      protocolContractsHash: this.protocolContractsHash.toString(),
+      proverId: this.proverId.toString(),
+      slotNumber: this.slotNumber.toNumber(),
+      coinbase: this.coinbase.toString(),
+      feeRecipient: this.feeRecipient.toString(),
+      gasFees: this.gasFees.toInspect(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `CheckpointConstantData ${inspect(this.toInspect())}`;
+  }
 }

package/src/tests/factories.ts

@@ -5,8 +5,6 @@ import {
   AZTEC_MAX_EPOCH_DURATION,
   CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  FIXED_DA_GAS,
-  FIXED_L2_GAS,
   GeneratorIndex,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
@@ -39,8 +37,8 @@ import {
   RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
-import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
-import { compact, padArrayEnd } from '@aztec/foundation/collection';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { compact } from '@aztec/foundation/collection';
 import { Grumpkin, SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fq, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
@@ -75,7 +73,6 @@ import {
   AvmSequentialInsertHintNullifierTree,
   AvmSequentialInsertHintPublicDataTree,
   AvmTxHint,
-  RevertCode,
 } from '../avm/index.js';
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
@@ -92,10 +89,8 @@ import {
   computeContractClassId,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
-import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
-import { Gas, GasFees, GasSettings, type GasUsed } from '../gas/index.js';
+import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
-import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
 import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
 import { ReadRequest } from '../kernel/hints/read_request.js';
@@ -132,7 +127,6 @@ import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
 import { ProofData } from '../proofs/index.js';
 import { Proof } from '../proofs/proof.js';
-import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { makeRecursiveProof } from '../proofs/recursive_proof.js';
 import { PrivateBaseRollupHints, PublicBaseRollupHints } from '../rollup/base_rollup_hints.js';
 import { BlockConstantData } from '../rollup/block_constant_data.js';
@@ -163,7 +157,6 @@ import { ContentCommitment } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/processed_tx.js';
 import { ProtocolContracts } from '../tx/protocol_contracts.js';
 import { PublicCallRequestWithCalldata } from '../tx/public_call_request_with_calldata.js';
 import { StateReference } from '../tx/state_reference.js';
@@ -174,7 +167,6 @@ import { TxRequest } from '../tx/tx_request.js';
 import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
 import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
-import { mockTx } from './mocks.js';
 
 /**
  * Creates an arbitrary side effect object with the given seed.
@@ -264,7 +256,7 @@ function makeKeyValidationRequestAndGenerators(seed: number): KeyValidationReque
   return new KeyValidationRequestAndGenerator(makeKeyValidationRequests(seed), fr(seed + 4));
 }
 
-function makePublicDataWrite(seed = 1) {
+export function makePublicDataWrite(seed = 1) {
   return new PublicDataWrite(fr(seed), fr(seed + 1));
 }
 
@@ -307,31 +299,101 @@ function makeTxConstantData(seed = 1) {
   return new TxConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201));
 }
 
+function makePaddedTuple<T, N extends number>(
+  length: N,
+  fn: (i: number) => T,
+  nonPaddedLength = 0,
+  makePadding: () => T,
+  offset = 0,
+) {
+  return makeTuple(length, i => (i < nonPaddedLength ? fn(i + offset) : makePadding()));
+}
+
 /**
  * Creates arbitrary accumulated data.
  * @param seed - The seed to use for generating the accumulated data.
  * @returns An accumulated data.
  */
-export function makePrivateToRollupAccumulatedData(seed = 1, full = false): PrivateToRollupAccumulatedData {
-  const tupleGenerator = full ? makeTuple : makeHalfFullTuple;
-
+export function makePrivateToRollupAccumulatedData(
+  seed = 1,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+  } = {},
+): PrivateToRollupAccumulatedData {
   return new PrivateToRollupAccumulatedData(
-    tupleGenerator(MAX_NOTE_HASHES_PER_TX, fr, seed + 0x120, Fr.zero),
-    tupleGenerator(MAX_NULLIFIERS_PER_TX, fr, seed + 0x200, Fr.zero),
-    tupleGenerator(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x600, ScopedL2ToL1Message.empty),
-    tupleGenerator(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, seed + 0x700, PrivateLog.empty),
-    tupleGenerator(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeScopedLogHash, seed + 0xa00, ScopedLogHash.empty), // contract class logs
+    makePaddedTuple(MAX_NOTE_HASHES_PER_TX, fr, numNoteHashes, Fr.zero, seed + 0x100),
+    makePaddedTuple(MAX_NULLIFIERS_PER_TX, fr, numNullifiers, Fr.zero, seed + 0x200),
+    makePaddedTuple(
+      MAX_L2_TO_L1_MSGS_PER_TX,
+      makeScopedL2ToL1Message,
+      numL2ToL1Messages,
+      ScopedL2ToL1Message.empty,
+      seed + 0x300,
+    ),
+    makePaddedTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, numPrivateLogs, PrivateLog.empty, seed + 0x400),
+    makePaddedTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_TX,
+      makeScopedLogHash,
+      numContractClassLogs,
+      ScopedLogHash.empty,
+      seed + 0x500,
+    ),
   );
 }
 
-export function makePrivateToPublicAccumulatedData(seed = 1) {
+export function makePrivateToPublicAccumulatedData(
+  seed = 1,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    numEnqueuedCalls = MAX_ENQUEUED_CALLS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+    numEnqueuedCalls?: number;
+  } = {},
+) {
   return new PrivateToPublicAccumulatedData(
-    makeTuple(MAX_NOTE_HASHES_PER_TX, fr, seed),
-    makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x100),
-    makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x200),
-    makeTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, seed + 0x700),
-    makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeScopedLogHash, seed + 0x900),
-    makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x500),
+    makePaddedTuple(MAX_NOTE_HASHES_PER_TX, fr, numNoteHashes, Fr.zero, seed),
+    makePaddedTuple(MAX_NULLIFIERS_PER_TX, fr, numNullifiers, Fr.zero, seed + 0x100),
+    makePaddedTuple(
+      MAX_L2_TO_L1_MSGS_PER_TX,
+      makeScopedL2ToL1Message,
+      numL2ToL1Messages,
+      ScopedL2ToL1Message.empty,
+      seed + 0x200,
+    ),
+    makePaddedTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, numPrivateLogs, PrivateLog.empty, seed + 0x300),
+    makePaddedTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_TX,
+      makeScopedLogHash,
+      numContractClassLogs,
+      ScopedLogHash.empty,
+      seed + 0x400,
+    ),
+    makePaddedTuple(
+      MAX_ENQUEUED_CALLS_PER_TX,
+      makePublicCallRequest,
+      numEnqueuedCalls,
+      PublicCallRequest.empty,
+      seed + 0x500,
+    ),
   );
 }
 
@@ -434,13 +496,10 @@ export function makeProtocolContracts(seed = 1) {
  * @param seed - The seed to use for generating the kernel circuit public inputs.
  * @returns Public kernel circuit public inputs.
  */
-export function makePrivateToRollupKernelCircuitPublicInputs(
-  seed = 1,
-  fullAccumulatedData = true,
-): PrivateToRollupKernelCircuitPublicInputs {
+export function makePrivateToRollupKernelCircuitPublicInputs(seed = 1): PrivateToRollupKernelCircuitPublicInputs {
   return new PrivateToRollupKernelCircuitPublicInputs(
     makeTxConstantData(seed + 0x100),
-    makePrivateToRollupAccumulatedData(seed, fullAccumulatedData),
+    makePrivateToRollupAccumulatedData(seed),
     makeGas(seed + 0x600),
     makeAztecAddress(seed + 0x700),
     BigInt(seed + 0x800),
@@ -1601,164 +1660,3 @@ export async function makeAvmCircuitInputs(
 export function fr(n: number): Fr {
   return new Fr(BigInt(n));
 }
-
-/** Makes a bloated processed tx for testing purposes. */
-export async function makeBloatedProcessedTx({
-  seed = 1,
-  header,
-  db,
-  chainId = Fr.ZERO,
-  version = Fr.ZERO,
-  gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) }),
-  vkTreeRoot = Fr.ZERO,
-  protocolContracts = makeProtocolContracts(seed + 0x100),
-  globalVariables = GlobalVariables.empty(),
-  newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
-  feePayer,
-  feePaymentPublicDataWrite,
-  // The default gasUsed is the tx overhead.
-  gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
-  privateOnly = false,
-}: {
-  seed?: number;
-  header?: BlockHeader;
-  db?: MerkleTreeReadOperations;
-  chainId?: Fr;
-  version?: Fr;
-  gasSettings?: GasSettings;
-  vkTreeRoot?: Fr;
-  globalVariables?: GlobalVariables;
-  newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
-  protocolContracts?: ProtocolContracts;
-  feePayer?: AztecAddress;
-  feePaymentPublicDataWrite?: PublicDataWrite;
-  gasUsed?: Gas;
-  privateOnly?: boolean;
-} = {}) {
-  seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
-  header ??= db?.getInitialHeader() ?? makeHeader(seed);
-  feePayer ??= await AztecAddress.random();
-
-  const txConstantData = TxConstantData.empty();
-  txConstantData.anchorBlockHeader = header!;
-  txConstantData.txContext.chainId = chainId;
-  txConstantData.txContext.version = version;
-  txConstantData.txContext.gasSettings = gasSettings;
-  txConstantData.vkTreeRoot = vkTreeRoot;
-  txConstantData.protocolContractsHash = await protocolContracts.hash();
-
-  const tx = !privateOnly
-    ? await mockTx(seed, { feePayer, gasUsed })
-    : await mockTx(seed, {
-        numberOfNonRevertiblePublicCallRequests: 0,
-        numberOfRevertiblePublicCallRequests: 0,
-        feePayer,
-        gasUsed,
-      });
-  tx.data.constants = txConstantData;
-
-  const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
-
-  if (privateOnly) {
-    const data = makePrivateToRollupAccumulatedData(seed + 0x1000);
-    clearContractClassLogs(data);
-
-    feePaymentPublicDataWrite ??= new PublicDataWrite(Fr.random(), Fr.random());
-
-    tx.data.forRollup!.end = data;
-
-    await tx.recomputeHash();
-    return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
-  } else {
-    const dataFromPrivate = tx.data.forPublic!;
-
-    const nonRevertibleData = dataFromPrivate.nonRevertibleAccumulatedData;
-
-    // Create revertible data.
-    const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000);
-    clearContractClassLogs(revertibleData);
-    revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
-    dataFromPrivate.revertibleAccumulatedData = revertibleData;
-
-    // Create avm output.
-    const avmOutput = AvmCircuitPublicInputs.empty();
-    // Assign data from hints.
-    avmOutput.protocolContracts = protocolContracts;
-    avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
-    avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
-    avmOutput.effectiveGasFees = computeEffectiveGasFees(globalVariables.gasFees, gasSettings);
-    // Assign data from private.
-    avmOutput.globalVariables = globalVariables;
-    avmOutput.startGasUsed = tx.data.gasUsed;
-    avmOutput.gasSettings = gasSettings;
-    avmOutput.feePayer = feePayer;
-    avmOutput.publicCallRequestArrayLengths = new PublicCallRequestArrayLengths(
-      tx.data.numberOfNonRevertiblePublicCallRequests(),
-      tx.data.numberOfRevertiblePublicCallRequests(),
-      tx.data.hasTeardownPublicCallRequest(),
-    );
-    avmOutput.publicSetupCallRequests = dataFromPrivate.nonRevertibleAccumulatedData.publicCallRequests;
-    avmOutput.publicAppLogicCallRequests = dataFromPrivate.revertibleAccumulatedData.publicCallRequests;
-    avmOutput.publicTeardownCallRequest = dataFromPrivate.publicTeardownCallRequest;
-    avmOutput.previousNonRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
-      dataFromPrivate.nonRevertibleAccumulatedData.noteHashes,
-      dataFromPrivate.nonRevertibleAccumulatedData.nullifiers,
-      dataFromPrivate.nonRevertibleAccumulatedData.l2ToL1Msgs,
-    );
-    avmOutput.previousNonRevertibleAccumulatedDataArrayLengths =
-      avmOutput.previousNonRevertibleAccumulatedData.getArrayLengths();
-    avmOutput.previousRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
-      dataFromPrivate.revertibleAccumulatedData.noteHashes,
-      dataFromPrivate.revertibleAccumulatedData.nullifiers,
-      dataFromPrivate.revertibleAccumulatedData.l2ToL1Msgs,
-    );
-    avmOutput.previousRevertibleAccumulatedDataArrayLengths =
-      avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
-    // Assign final data emitted from avm.
-    avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
-    avmOutput.accumulatedData.nullifiers = padArrayEnd(
-      nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
-      Fr.ZERO,
-      MAX_NULLIFIERS_PER_TX,
-    );
-    avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
-    avmOutput.accumulatedData.publicDataWrites = makeTuple(
-      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-      i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
-      seed + 0x2000,
-    );
-    avmOutput.accumulatedDataArrayLengths = avmOutput.accumulatedData.getArrayLengths();
-    avmOutput.gasSettings = gasSettings;
-    // Note: The fee is computed from the tx's gas used, which only includes the gas used in private. But this shouldn't
-    // be a problem for the tests.
-    avmOutput.transactionFee = transactionFee;
-
-    const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
-    avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
-
-    const gasUsed = {
-      totalGas: Gas.empty(),
-      teardownGas: Gas.empty(),
-      publicGas: Gas.empty(),
-      billedGas: Gas.empty(),
-    } satisfies GasUsed;
-
-    await tx.recomputeHash();
-    return makeProcessedTxFromTxWithPublicCalls(
-      tx,
-      {
-        type: ProvingRequestType.PUBLIC_VM,
-        inputs: avmCircuitInputs,
-      },
-      gasUsed,
-      RevertCode.OK,
-      undefined /* revertReason */,
-    );
-  }
-}
-
-// Remove all contract class log hashes from the data as they are not required for the current tests.
-// If they are needed one day, change this to create the random fields first and update the data with real hashes of those fields.
-function clearContractClassLogs(data: { contractClassLogsHashes: ScopedLogHash[] }) {
-  data.contractClassLogsHashes.forEach((_, i) => (data.contractClassLogsHashes[i] = ScopedLogHash.empty()));
-}