@aztec/stdlib 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/src/block/l2_block_new.ts

@@ -1,211 +0,0 @@
-import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import type { PrivateLog } from '../logs/private_log.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
-import { Body } from './body.js';
-import type { L2BlockInfo } from './l2_block_info.js';
-
-// TODO(palla/mbps): Delete the existing `L2Block` class and rename this to `L2Block`.
-// TODO(palla/mbps): Consider moving the checkpointNumber and indexWithinCheckpoint to the header:
-// if the blockNumber is there, why not these as well? Consider whether they should be part of the
-// circuits structs though.
-
-/**
- * An L2 block with a header and a body.
- */
-export class L2BlockNew {
-  constructor(
-    /** Snapshot of archive tree after the block is applied. */
-    public archive: AppendOnlyTreeSnapshot,
-    /** Header of the block. */
-    public header: BlockHeader,
-    /** L2 block body. */
-    public body: Body,
-    /** Number of the checkpoint that the block belongs to. */
-    public checkpointNumber: CheckpointNumber,
-    /** Index of the block within the checkpoint. */
-    public indexWithinCheckpoint: number,
-  ) {}
-
-  get number(): BlockNumber {
-    return this.header.globalVariables.blockNumber;
-  }
-
-  get timestamp(): bigint {
-    return this.header.globalVariables.timestamp;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
-        body: Body.schema,
-        checkpointNumber: CheckpointNumberSchema,
-        indexWithinCheckpoint: z.number(),
-      })
-      .transform(
-        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
-      );
-  }
-
-  /**
-   * Deserializes a block from a buffer
-   * @returns A deserialized L2 block.
-   */
-  static fromBuffer(buf: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(BlockHeader);
-    const archive = reader.readObject(AppendOnlyTreeSnapshot);
-    const body = reader.readObject(Body);
-    const checkpointNumber = CheckpointNumber(reader.readNumber());
-    const indexWithinCheckpoint = reader.readNumber();
-
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Serializes a block
-   * @returns A serialized L2 block as a Buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
-  }
-
-  /**
-   * Checks if this block equals another block.
-   * @param other - The other block to compare with.
-   * @returns True if both blocks are equal.
-   */
-  public equals(other: this): boolean {
-    return (
-      this.archive.equals(other.archive) &&
-      this.header.equals(other.header) &&
-      this.body.equals(other.body) &&
-      this.checkpointNumber === other.checkpointNumber &&
-      this.indexWithinCheckpoint === other.indexWithinCheckpoint
-    );
-  }
-
-  public toBlobFields(): Fr[] {
-    const blockBlobData = this.toBlockBlobData();
-    return encodeBlockBlobData(blockBlobData);
-  }
-
-  public toBlockBlobData(): BlockBlobData {
-    const isFirstBlock = this.indexWithinCheckpoint === 0;
-    return {
-      blockEndMarker: {
-        numTxs: this.body.txEffects.length,
-        timestamp: this.header.globalVariables.timestamp,
-        blockNumber: this.number,
-      },
-      blockEndStateField: {
-        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
-        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
-        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
-        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
-        totalManaUsed: this.header.totalManaUsed.toBigInt(),
-      },
-      lastArchiveRoot: this.header.lastArchive.root,
-      noteHashRoot: this.header.state.partial.noteHashTree.root,
-      nullifierRoot: this.header.state.partial.nullifierTree.root,
-      publicDataRoot: this.header.state.partial.publicDataTree.root,
-      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
-      txs: this.body.toTxBlobData(),
-    };
-  }
-
-  static empty() {
-    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty(), CheckpointNumber(0), 0);
-  }
-
-  /**
-   * Creates an L2 block containing random data.
-   * @param l2BlockNum - The number of the L2 block.
-   * @param txsPerBlock - The number of transactions to include in the block.
-   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
-   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
-   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
-   * @returns The L2 block.
-   */
-  static async random(
-    blockNumber: BlockNumber,
-    {
-      checkpointNumber = CheckpointNumber(Number(blockNumber)),
-      indexWithinCheckpoint = 0,
-      txsPerBlock = 1,
-      txOptions = {},
-      makeTxOptions,
-      ...blockHeaderOverrides
-    }: {
-      checkpointNumber?: CheckpointNumber;
-      indexWithinCheckpoint?: number;
-      txsPerBlock?: number;
-      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
-      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
-    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2BlockNew> {
-    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
-    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns stats used for logging.
-   * @returns Stats on tx count, number, and log size and count.
-   */
-  getStats() {
-    const logsStats = {
-      privateLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.privateLogs.length, 0),
-      publicLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.publicLogs.length, 0),
-      contractClassLogCount: this.body.txEffects.reduce(
-        (logCount, txEffect) => logCount + txEffect.contractClassLogs.length,
-        0,
-      ),
-      contractClassLogSize: this.body.txEffects.reduce(
-        (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
-        0,
-      ),
-    };
-
-    return {
-      txCount: this.body.txEffects.length,
-      blockNumber: this.number,
-      blockTimestamp: Number(this.header.globalVariables.timestamp),
-      ...logsStats,
-    };
-  }
-
-  getPrivateLogs(): PrivateLog[] {
-    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
-  }
-
-  toBlockInfo(): L2BlockInfo {
-    return {
-      archive: this.archive.root,
-      lastArchive: this.header.lastArchive.root,
-      blockNumber: this.number,
-      slotNumber: this.header.getSlot(),
-      txCount: this.body.txEffects.length,
-      timestamp: this.header.globalVariables.timestamp,
-    };
-  }
-}

package/src/contract/contract_class_metadata.ts

@@ -1,8 +0,0 @@
-import type { ContractArtifact } from '../abi/abi.js';
-import type { ContractClassWithId } from './interfaces/contract_class.js';
-
-export interface ContractClassMetadata {
-  contractClass?: ContractClassWithId | undefined;
-  isContractClassPubliclyRegistered: boolean;
-  artifact?: ContractArtifact | undefined;
-}

package/src/contract/contract_metadata.ts

@@ -1,7 +0,0 @@
-import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
-
-export interface ContractMetadata {
-  contractInstance?: ContractInstanceWithAddress | undefined;
-  isContractInitialized: boolean;
-  isContractPublished: boolean;
-}

package/src/contract/private_function_membership_proof.ts

@@ -1,167 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-
-import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
-import {
-  computeArtifactFunctionTree,
-  computeArtifactHash,
-  computeArtifactHashPreimage,
-  computeFunctionArtifactHash,
-  computeFunctionMetadataHash,
-  getArtifactMerkleTreeHasher,
-} from './artifact_hash.js';
-import { getContractClassPrivateFunctionFromArtifact } from './contract_class.js';
-import type {
-  ContractClassPublic,
-  ExecutablePrivateFunctionWithMembershipProof,
-  PrivateFunctionMembershipProof,
-} from './interfaces/index.js';
-import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './private_function.js';
-
-/**
- * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export async function createPrivateFunctionMembershipProof(
-  selector: FunctionSelector,
-  artifact: ContractArtifact,
-): Promise<PrivateFunctionMembershipProof> {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Locate private function definition and artifact
-  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
-  const privateFunctionsFromArtifact = await Promise.all(
-    privateFunctions.map(getContractClassPrivateFunctionFromArtifact),
-  );
-  const privateFunction = privateFunctionsFromArtifact.find(fn => fn.selector.equals(selector));
-  const privateFunctionsAndSelectors = await Promise.all(
-    privateFunctions.map(async fn => ({
-      fn,
-      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
-    })),
-  );
-  const privateFunctionArtifact = privateFunctionsAndSelectors.find(fnAndSelector =>
-    selector.equals(fnAndSelector.selector),
-  )?.fn;
-  if (!privateFunction || !privateFunctionArtifact) {
-    throw new Error(`Private function with selector ${selector.toString()} not found`);
-  }
-
-  // Compute preimage for the artifact hash
-  const { utilityFunctionRoot: utilityFunctionsTreeRoot, metadataHash: artifactMetadataHash } =
-    await computeArtifactHashPreimage(artifact);
-
-  // We need two sibling paths because private function information is split across two trees:
-  // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
-  const functionLeaf = await computePrivateFunctionLeaf(privateFunction);
-  const functionsTree = await computePrivateFunctionsTree(privateFunctionsFromArtifact);
-  const functionsTreeLeafIndex = functionsTree.getIndex(functionLeaf);
-  const functionsTreeSiblingPath = functionsTree.getSiblingPath(functionsTreeLeafIndex).map(Fr.fromBuffer);
-
-  // And the "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
-  const functionMetadataHash = computeFunctionMetadataHash(privateFunctionArtifact);
-  const functionArtifactHash = await computeFunctionArtifactHash({ ...privateFunctionArtifact, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.PRIVATE))!;
-  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-
-  log.debug(`Computed proof for private function with selector ${selector.toString()}`, {
-    functionArtifactHash,
-    functionMetadataHash,
-    functionLeaf: '0x' + functionLeaf.toString('hex'),
-    artifactMetadataHash,
-    privateFunctionsTreeRoot: '0x' + functionsTree.root.toString('hex'),
-    utilityFunctionsTreeRoot,
-    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    privateFunctionTreeSiblingPath: functionsTreeSiblingPath.map(fr => fr.toString()).join(','),
-  });
-
-  return {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    utilityFunctionsTreeRoot,
-    privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
-    privateFunctionTreeLeafIndex: functionsTreeLeafIndex,
-  };
-}
-
-/**
- * Verifies that a private function with a membership proof as emitted by the ClassRegistry contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute function leaf and assert it belongs to the private functions tree
- * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
- * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_functions_root
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
- * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, utility_functions_artifact_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export async function isValidPrivateFunctionMembershipProof(
-  fn: ExecutablePrivateFunctionWithMembershipProof,
-  contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>,
-) {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Check private function tree membership
-  const functionLeaf = await computePrivateFunctionLeaf(fn);
-  const rootBuffer = await computeRootFromSiblingPath(
-    functionLeaf,
-    fn.privateFunctionTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.privateFunctionTreeLeafIndex,
-    async (left, right) => (await poseidon2Hash([left, right])).toBuffer(),
-  );
-  const computedPrivateFunctionTreeRoot = Fr.fromBuffer(rootBuffer);
-  if (!contractClass.privateFunctionsRoot.equals(computedPrivateFunctionTreeRoot)) {
-    log.debug(`Private function tree root mismatch`, {
-      expectedPrivateFunctionTreeRoot: contractClass.privateFunctionsRoot,
-      computedPrivateFunctionTreeRoot: computedPrivateFunctionTreeRoot,
-      computedFunctionLeaf: '0x' + functionLeaf.toString('hex'),
-    });
-    return false;
-  }
-
-  // Check artifact hash
-  const functionArtifactHash = await computeFunctionArtifactHash(fn);
-  const computedArtifactPrivateFunctionTreeRootBuffer = await computeRootFromSiblingPath(
-    functionArtifactHash.toBuffer(),
-    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.artifactTreeLeafIndex,
-    getArtifactMerkleTreeHasher(),
-  );
-  const computedArtifactPrivateFunctionTreeRoot = Fr.fromBuffer(computedArtifactPrivateFunctionTreeRootBuffer);
-  const computedArtifactHash = await computeArtifactHash({
-    privateFunctionRoot: computedArtifactPrivateFunctionTreeRoot,
-    utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
-    metadataHash: fn.artifactMetadataHash,
-  });
-  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-    log.debug(`Artifact hash mismatch`, {
-      expected: contractClass.artifactHash,
-      computedArtifactHash,
-      computedFunctionArtifactHash: functionArtifactHash,
-      computedArtifactPrivateFunctionTreeRoot,
-      utilityFunctionRoot: fn.utilityFunctionsTreeRoot,
-      metadataHash: fn.artifactMetadataHash,
-      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    });
-    return false;
-  }
-
-  return true;
-}

package/src/contract/utility_function_membership_proof.ts

@@ -1,118 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-
-import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
-import {
-  computeArtifactFunctionTree,
-  computeArtifactHash,
-  computeArtifactHashPreimage,
-  computeFunctionArtifactHash,
-  computeFunctionMetadataHash,
-  getArtifactMerkleTreeHasher,
-} from './artifact_hash.js';
-import type {
-  ContractClassPublic,
-  UtilityFunctionMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from './interfaces/index.js';
-
-/**
- * Creates a membership proof for a utility  function in a contract class, to be verified via `isValidUtilityFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export async function createUtilityFunctionMembershipProof(
-  selector: FunctionSelector,
-  artifact: ContractArtifact,
-): Promise<UtilityFunctionMembershipProof> {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Locate function artifact
-  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
-  const utilityFunctionsAndSelectors = await Promise.all(
-    utilityFunctions.map(async fn => ({ fn, selector: await FunctionSelector.fromNameAndParameters(fn) })),
-  );
-  const fn = utilityFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
-  if (!fn) {
-    throw new Error(`Utility function with selector ${selector.toString()} not found`);
-  }
-  // Compute preimage for the artifact hash
-  const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
-    await computeArtifactHashPreimage(artifact);
-
-  // Compute the sibling path for the "artifact tree"
-  const functionMetadataHash = computeFunctionMetadataHash(fn);
-  const functionArtifactHash = await computeFunctionArtifactHash({ ...fn, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.UTILITY))!;
-  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-
-  log.debug(`Computed proof for utility function with selector ${selector.toString()}`, {
-    functionArtifactHash,
-    functionMetadataHash,
-    artifactMetadataHash,
-    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    privateFunctionsArtifactTreeRoot,
-  });
-
-  return {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-  };
-}
-
-/**
- * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_utility_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
- * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_utility_function_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export async function isValidUtilityFunctionMembershipProof(
-  fn: UtilityFunctionWithMembershipProof,
-  contractClass: Pick<ContractClassPublic, 'artifactHash'>,
-) {
-  const log = createLogger('circuits:function_membership_proof');
-
-  const functionArtifactHash = await computeFunctionArtifactHash(fn);
-  const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(
-    functionArtifactHash.toBuffer(),
-    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.artifactTreeLeafIndex,
-    getArtifactMerkleTreeHasher(),
-  );
-  const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
-  const computedArtifactHash = await computeArtifactHash({
-    privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
-    utilityFunctionRoot: computedArtifactFunctionTreeRoot,
-    metadataHash: fn.artifactMetadataHash,
-  });
-  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-    log.debug(`Artifact hash mismatch`, {
-      expected: contractClass.artifactHash,
-      computedArtifactHash,
-      computedFunctionArtifactHash: functionArtifactHash,
-      computedArtifactFunctionTreeRoot,
-      privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
-      metadataHash: fn.artifactMetadataHash,
-      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    });
-    return false;
-  }
-
-  return true;
-}

package/src/database-version/index.ts

@@ -1 +0,0 @@
-export * from './version_manager.js';

package/src/interfaces/get_logs_response.ts

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-
-import { ExtendedContractClassLog } from '../logs/extended_contract_class_log.js';
-import { ExtendedPublicLog } from '../logs/extended_public_log.js';
-import { zodFor } from '../schemas/index.js';
-
-/** Response for the getContractClassLogs archiver call. */
-export type GetContractClassLogsResponse = {
-  /** An array of ExtendedContractClassLog elements. */
-  logs: ExtendedContractClassLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetContractClassLogsResponseSchema = zodFor<GetContractClassLogsResponse>()(
-  z.object({
-    logs: z.array(ExtendedContractClassLog.schema),
-    maxLogsHit: z.boolean(),
-  }),
-);
-
-/** Response for the getPublicLogs archiver call. */
-export type GetPublicLogsResponse = {
-  /** An array of ExtendedPublicLog elements. */
-  logs: ExtendedPublicLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetPublicLogsResponseSchema = zodFor<GetPublicLogsResponse>()(
-  z.object({
-    logs: z.array(ExtendedPublicLog.schema),
-    maxLogsHit: z.boolean(),
-  }),
-);