@aztec/stdlib 1.2.0 → 2.0.0-nightly.20250813

package/src/messaging/l2_to_l1_membership.ts

@@ -1,13 +1,26 @@
-import { SHA256Trunc } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { MerkleTreeCalculator, SiblingPath, UnbalancedMerkleTreeCalculator } from '@aztec/foundation/trees';
+import {
+  SiblingPath,
+  UnbalancedMerkleTreeCalculator,
+  computeUnbalancedMerkleTreeRoot,
+  findLeafLevelAndIndex,
+  getMaxUnbalancedTreeDepth,
+} from '@aztec/foundation/trees';
+
+async function createOutHashTree(messages: Fr[]) {
+  const messageSubtreeHeight = getMaxUnbalancedTreeDepth(messages.length);
+  const calculator = UnbalancedMerkleTreeCalculator.create(messageSubtreeHeight);
+  await calculator.appendLeaves(messages.map(msg => msg.toBuffer()));
+  return calculator;
+}
 
 export interface MessageRetrieval {
   getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
 }
 
 export type L2ToL1MembershipWitness = {
-  l2MessageIndex: bigint;
+  root: Fr;
+  leafIndex: bigint;
   siblingPath: SiblingPath<number>;
 };
 
@@ -16,98 +29,76 @@ export async function computeL2ToL1MembershipWitness(
   l2BlockNumber: number,
   message: Fr,
 ): Promise<L2ToL1MembershipWitness | undefined> {
-  const messagesPerTx = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
-  if (!messagesPerTx) {
+  const messagesForAllTxs = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
+  if (!messagesForAllTxs) {
     return undefined;
   }
 
-  // Find index of message in subtree and index of tx in a block
-  let messageIndexInTx = -1,
-    txIndex = -1;
-  {
-    txIndex = messagesPerTx.findIndex(messages => {
-      const idx = messages.findIndex(msg => msg.equals(message));
-      messageIndexInTx = Math.max(messageIndexInTx, idx);
-      return idx !== -1;
-    });
-  }
+  return computeL2ToL1MembershipWitnessFromMessagesForAllTxs(messagesForAllTxs, message);
+}
+
+export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
+  messagesForAllTxs: Fr[][],
+  message: Fr,
+): Promise<L2ToL1MembershipWitness> {
+  // Find index of message in subtree and index of tx in a block.
+  let messageIndexInTx = -1;
+  const txIndex = messagesForAllTxs.findIndex(messages => {
+    messageIndexInTx = messages.findIndex(msg => msg.equals(message));
+    return messageIndexInTx !== -1;
+  });
 
   if (txIndex === -1) {
     throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
   }
 
-  const hasher = new SHA256Trunc();
-
-  // Get the message path in subtree and message subtree height
-  let messagePathInSubtree: SiblingPath<number>;
-  let messageSubtreeHeight: number;
-  {
-    const txMessages = messagesPerTx[txIndex];
-    messageSubtreeHeight = txMessages.length <= 1 ? 1 : Math.ceil(Math.log2(txMessages.length));
-    const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
-      messageSubtreeHeight,
-      Buffer.alloc(32, 0), // Zero leaf
-      (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
-    );
-
-    const tree = await calculator.computeTree(txMessages.map(msg => msg.toBuffer()));
-    const tempPath = tree.getSiblingPath(messageIndexInTx);
-    messagePathInSubtree = new SiblingPath(tempPath.length, tempPath);
-  }
-
-  // If the number of txs is 1 we are dealing with a special case where the tx subtree itself is the whole block's
-  // l2 to l1 message tree.
-  const numTransactions = messagesPerTx.length;
-  if (numTransactions === 1) {
-    return {
-      l2MessageIndex: BigInt(messageIndexInTx),
-      siblingPath: messagePathInSubtree,
-    };
-  }
-
-  // Calculate roots for all tx subtrees
-  const txSubtreeRoots = await Promise.all(
-    messagesPerTx.map(async (messages, _) => {
-      // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
-      if (messages.length === 0) {
-        return Fr.ZERO;
-      }
-
-      const txTreeHeight = messages.length <= 1 ? 1 : Math.ceil(Math.log2(messages.length));
-      const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
-        txTreeHeight,
-        Buffer.alloc(32, 0), // Zero leaf
-        (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
-      );
-
-      const root = await calculator.computeTreeRoot(messages.map(msg => msg.toBuffer()));
-      return Fr.fromBuffer(root);
-    }),
-  );
-
-  // Construct the top tree and compute the combined path
-  let combinedPath: Buffer[];
-  {
-    const topTreeHeight = Math.ceil(Math.log2(txSubtreeRoots.length));
-    // The root of this tree is the out_hash calculated in Noir => we truncate to match Noir's SHA
-    const topTree = UnbalancedMerkleTreeCalculator.create(topTreeHeight, (lhs: Buffer, rhs: Buffer) =>
-      Promise.resolve(hasher.hash(lhs, rhs)),
-    );
-    await topTree.appendLeaves(txSubtreeRoots.map(f => f.toBuffer()));
-
-    const txPathInTopTree = await topTree.getSiblingPath(txSubtreeRoots[txIndex].toBigInt());
-    // Append subtree path to top tree path
-    combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
-  }
-
-  // Append binary index of subtree path to binary index of top tree path
-  const combinedIndex = parseInt(
-    txIndex.toString(2).concat(messageIndexInTx.toString(2).padStart(messageSubtreeHeight, '0')),
-    2,
-  );
+  // Get the txOutHash and the sibling path of the message in the tx subtree.
+  const txMessages = messagesForAllTxs[txIndex];
+  const txOutHashTree = await createOutHashTree(txMessages);
+  const txOutHash = txOutHashTree.getRoot();
+  const messagePathInSubtree = await txOutHashTree.getSiblingPath(message);
+
+  // Calculate txOutHash for all txs.
+  const txSubtreeRoots = messagesForAllTxs.map((messages, i) => {
+    // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
+    if (messages.length === 0) {
+      return Fr.ZERO;
+    }
+
+    if (i === txIndex) {
+      return Fr.fromBuffer(txOutHash);
+    }
+
+    const root = computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer()));
+    return Fr.fromBuffer(root);
+  });
+
+  // Construct the top tree.
+  // The leaves of this tree are the txOutHashes.
+  // The root of this tree is the out_hash calculated in the circuit.
+  const topTree = await createOutHashTree(txSubtreeRoots);
+  const root = Fr.fromBuffer(topTree.getRoot());
+
+  // Compute the combined sibling path by appending the tx subtree path to the top tree path.
+  const txPathInTopTree = await topTree.getSiblingPath(txOutHash);
+  const combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
+
+  // Compute the combined index.
+  // It is the index of the message in the balanced tree at its current height.
+  const txLeafPosition = findLeafLevelAndIndex(messagesForAllTxs.length, txIndex);
+  const messageLeafPosition = findLeafLevelAndIndex(txMessages.length, messageIndexInTx);
+  const numLeavesInLeftSubtrees = txLeafPosition.indexAtLevel * (1 << messageLeafPosition.level);
+  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.indexAtLevel;
 
   return {
-    l2MessageIndex: BigInt(combinedIndex),
+    root,
+    leafIndex: BigInt(combinedIndex),
     siblingPath: new SiblingPath(combinedPath.length, combinedPath),
   };
 }
+
+export function getL2ToL1MessageLeafId(
+  membershipWitness: Pick<L2ToL1MembershipWitness, 'leafIndex' | 'siblingPath'>,
+): bigint {
+  return 2n ** BigInt(membershipWitness.siblingPath.pathSize) + membershipWitness.leafIndex;
+}

package/src/messaging/l2_to_l1_message.ts

@@ -203,4 +203,13 @@ export class ScopedCountedL2ToL1Message {
   toBuffer(): Buffer {
     return serializeToBuffer(this.inner, this.contractAddress);
   }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(this.inner, this.contractAddress);
+  }
 }

package/src/note/notes_filter.ts

@@ -12,10 +12,13 @@ import { NoteStatus } from './note_status.js';
  * @remarks This filter is applied as an intersection of all its params.
  */
 export type NotesFilter = {
+  /**
+   * The contract address the note belongs to.
+   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
+   */
+  contractAddress: AztecAddress;
   /** Hash of a transaction from which to fetch the notes. */
   txHash?: TxHash;
-  /** The contract address the note belongs to. */
-  contractAddress?: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
   /** The recipient of the note (whose public key was used to encrypt the note). */
@@ -29,8 +32,8 @@ export type NotesFilter = {
 };
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
+  contractAddress: schemas.AztecAddress,
   txHash: TxHash.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
   recipient: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),

package/src/p2p/attestation_utils.ts

@@ -0,0 +1,35 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { CommitteeAttestation } from '../block/index.js';
+import type { BlockAttestation } from './block_attestation.js';
+
+/**
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export function orderAttestations(
+  attestations: BlockAttestation[],
+  orderAddresses: EthAddress[],
+): CommitteeAttestation[] {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, CommitteeAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = attestation.getSender();
+    if (sender) {
+      attestationMap.set(
+        sender.toString(),
+        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+      );
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty attestation
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString) || CommitteeAttestation.fromAddress(address);
+  });
+
+  return orderedAttestations;
+}

package/src/p2p/block_attestation.ts

@@ -66,10 +66,9 @@ export class BlockAttestation extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  /**Get sender
-   *
-   * Lazily evaluate and cache the sender of the attestation
-   * @returns The sender of the attestation
+  /**
+   * Lazily evaluate and cache the signer of the attestation
+   * @returns The signer of the attestation
    */
   getSender(): EthAddress {
     if (!this.sender) {

package/src/p2p/block_proposal.ts

@@ -5,6 +5,8 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { BlockInfo } from '../block/l2_block.js';
+import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
@@ -47,6 +49,9 @@ export class BlockProposal extends Gossipable {
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
 
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
+
     // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
     /** The transactions in the block */
     public readonly txs?: Tx[],
@@ -66,9 +71,19 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
+  toBlockInfo(): BlockInfo {
+    return {
+      blockNumber: this.blockNumber,
+      slotNumber: this.slotNumber.toNumber(),
+      archive: this.archive.toString(),
+      txCount: this.txHashes.length,
+    };
+  }
+
   static async createProposalFromSigner(
     blockNumber: UInt32,
     payload: ConsensusPayload,
+    txHashes: TxHash[],
     // Note(md): Provided separately to tx hashes such that this function can be optional
     txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
@@ -76,7 +91,7 @@ export class BlockProposal extends Gossipable {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig, txs);
+    return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
   }
 
   /**Get Sender
@@ -97,7 +112,7 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.blockNumber, this.payload, this.signature];
+    const buffer: any[] = [this.blockNumber, this.payload, this.signature, this.txHashes.length, this.txHashes];
     if (this.txs) {
       buffer.push(this.txs.length);
       buffer.push(this.txs);
@@ -111,13 +126,14 @@ export class BlockProposal extends Gossipable {
     const blockNumber = reader.readNumber();
     const payload = reader.readObject(ConsensusPayload);
     const sig = reader.readObject(Signature);
+    const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
       const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(blockNumber, payload, sig, txs);
+      return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
     }
 
-    return new BlockProposal(blockNumber, payload, sig);
+    return new BlockProposal(blockNumber, payload, sig, txHashes);
   }
 
   getSize(): number {
@@ -125,7 +141,9 @@ export class BlockProposal extends Gossipable {
       4 /* blockNumber */ +
       this.payload.getSize() +
       this.signature.getSize() +
-      (this.txs ? this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+      4 /* txHashes.length */ +
+      this.txHashes.length * TxHash.SIZE +
+      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
     );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -8,7 +8,7 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
-import { ProposedBlockHeader, StateReference, TxHash } from '../tx/index.js';
+import { ProposedBlockHeader, StateReference } from '../tx/index.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -21,8 +21,6 @@ export class ConsensusPayload implements Signable {
     public readonly archive: Fr,
     /** The state reference after the block is added */
     public readonly stateReference: StateReference,
-    /** The sequence of transactions in the block */
-    public readonly txHashes: TxHash[],
   ) {}
 
   static get schema() {
@@ -31,13 +29,12 @@ export class ConsensusPayload implements Signable {
         header: ProposedBlockHeader.schema,
         archive: schemas.Fr,
         stateReference: StateReference.schema,
-        txHashes: z.array(TxHash.schema),
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference, obj.txHashes));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.stateReference, fields.txHashes] as const;
+    return [fields.header, fields.archive, fields.stateReference] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -47,31 +44,23 @@ export class ConsensusPayload implements Signable {
         'bytes32, ' + // archive
         '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
-        'bytes32, ' + // headerHash
-        'bytes32[]' + // txHashes
+        'bytes32' + // headerHash
         ')',
     );
     const archiveRoot = this.archive.toString();
     const stateReference = this.stateReference.toAbi();
 
     const headerHash = this.header.hash().toString();
-    const txArray = this.txHashes.map(tx => tx.toString());
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash, txArray],
+      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([
-      this.header,
-      this.archive,
-      this.stateReference,
-      this.txHashes.length,
-      this.txHashes,
-    ]);
+    const buffer = serializeToBuffer([this.header, this.archive, this.stateReference]);
     this.size = buffer.length;
     return buffer;
   }
@@ -82,25 +71,19 @@ export class ConsensusPayload implements Signable {
       reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
-      reader.readArray(reader.readNumber(), TxHash),
     );
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference, fields.txHashes);
+    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(
-      block.header.toPropose(),
-      block.archive.root,
-      block.header.state,
-      block.body.txEffects.map(tx => tx.txHash),
-    );
+    return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty(), []);
+    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
   }
 
   /**
@@ -117,8 +100,6 @@ export class ConsensusPayload implements Signable {
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(
-      ', ',
-    )}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
   }
 }

package/src/p2p/index.ts

@@ -1,3 +1,4 @@
+export * from './attestation_utils.js';
 export * from './block_attestation.js';
 export * from './block_proposal.js';
 export * from './consensus_payload.js';

package/src/p2p/topic_type.ts

@@ -24,8 +24,10 @@ export function getTopicTypeForClientType(clientType: P2PClientType) {
     return Object.values(TopicType);
   } else if (clientType === P2PClientType.Prover) {
     return [TopicType.tx, TopicType.block_proposal];
+  } else {
+    const _: never = clientType;
+    return [TopicType.tx];
   }
-  return [TopicType.tx];
 }
 
 /**

package/src/slashing/index.ts

@@ -0,0 +1,74 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { z } from 'zod';
+
+import { type ZodFor, schemas } from '../schemas/index.js';
+
+export enum Offense {
+  UNKNOWN = 0,
+  DATA_WITHHOLDING = 1,
+  VALID_EPOCH_PRUNED = 2,
+  INACTIVITY = 3,
+  /** A proposer sent an invalid block proposal over the p2p network to the committee */
+  BROADCASTED_INVALID_BLOCK_PROPOSAL = 4,
+  /** A proposer pushed to L1 a block with insufficient committee attestations */
+  PROPOSED_INSUFFICIENT_ATTESTATIONS = 5,
+  /** A proposer pushed to L1 a block with incorrect committee attestations (ie signature from a non-committee member) */
+  PROPOSED_INCORRECT_ATTESTATIONS = 6,
+  /** A committee member attested to a block that was built as a descendent of an invalid block (as in a block with invalid attestations) */
+  ATTESTED_DESCENDANT_OF_INVALID = 7,
+}
+
+export const OffenseSchema = z.nativeEnum(Offense);
+
+export type MonitoredSlashPayload = {
+  payloadAddress: EthAddress;
+  validators: readonly EthAddress[];
+  amounts: readonly bigint[];
+  offenses: readonly Offense[];
+  observedAtSeconds: number;
+  totalAmount: bigint;
+};
+
+export const MonitoredSlashPayloadSchema = z.object({
+  payloadAddress: schemas.EthAddress,
+  validators: z.array(schemas.EthAddress),
+  amounts: z.array(schemas.BigInt),
+  offenses: z.array(OffenseSchema),
+  observedAtSeconds: z.number(),
+  totalAmount: schemas.BigInt,
+}) satisfies ZodFor<MonitoredSlashPayload>;
+
+export const OffenseToBigInt: Record<Offense, bigint> = {
+  [Offense.UNKNOWN]: 0n,
+  [Offense.DATA_WITHHOLDING]: 1n,
+  [Offense.VALID_EPOCH_PRUNED]: 2n,
+  [Offense.INACTIVITY]: 3n,
+  [Offense.BROADCASTED_INVALID_BLOCK_PROPOSAL]: 4n,
+  [Offense.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
+  [Offense.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
+  [Offense.ATTESTED_DESCENDANT_OF_INVALID]: 7n,
+};
+
+export function bigIntToOffense(offense: bigint): Offense {
+  switch (offense) {
+    case 0n:
+      return Offense.UNKNOWN;
+    case 1n:
+      return Offense.DATA_WITHHOLDING;
+    case 2n:
+      return Offense.VALID_EPOCH_PRUNED;
+    case 3n:
+      return Offense.INACTIVITY;
+    case 4n:
+      return Offense.BROADCASTED_INVALID_BLOCK_PROPOSAL;
+    case 5n:
+      return Offense.PROPOSED_INSUFFICIENT_ATTESTATIONS;
+    case 6n:
+      return Offense.PROPOSED_INCORRECT_ATTESTATIONS;
+    case 7n:
+      return Offense.ATTESTED_DESCENDANT_OF_INVALID;
+    default:
+      throw new Error(`Unknown offense: ${offense}`);
+  }
+}

package/src/stats/stats.ts

@@ -221,8 +221,8 @@ export type TxStats = {
   nullifierCount: number;
   /** Number of private logs */
   privateLogCount: number;
-  /** How many classes were registered through the canonical class registerer. */
-  classRegisteredCount: number;
+  /** How many classes were published to the canonical class registry. */
+  classPublishedCount: number;
   /** Serialized size of contract class logs in fields. */
   contractClassLogSize: number;
   /** How this tx pays for its fee */