@aztec/archiver 0.0.1-commit.b1c78909e → 0.0.1-commit.b2a5d0dd1

package/src/factory.ts

@@ -1,5 +1,6 @@
 import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
+import { makeL1HttpTransport } from '@aztec/ethereum/client';
 import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { BlockNumber } from '@aztec/foundation/branded-types';
@@ -12,12 +13,12 @@ import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter } from '@aztec/stdlib/block';
-import { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import { type ContractClassPublicWithCommitment, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
-import { createPublicClient, fallback, http } from 'viem';
+import { createPublicClient } from 'viem';
 
 import { Archiver, type ArchiverDeps } from './archiver.js';
 import { type ArchiverConfig, mapArchiverConfig } from './config.js';
@@ -57,9 +58,10 @@ export async function createArchiver(
 
   // Create Ethereum clients
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  const httpTimeout = config.l1HttpTimeoutMS;
   const publicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(config.l1RpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: httpTimeout }),
     pollingInterval: config.viemPollingIntervalMS,
   });
 
@@ -67,7 +69,7 @@ export async function createArchiver(
   const debugRpcUrls = config.l1DebugRpcUrls.length > 0 ? config.l1DebugRpcUrls : config.l1RpcUrls;
   const debugClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(debugRpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(debugRpcUrls, { timeout: httpTimeout }),
     pollingInterval: config.viemPollingIntervalMS,
   }) as ViemPublicDebugClient;
 
@@ -119,6 +121,7 @@ export async function createArchiver(
       batchSize: 100,
       maxAllowedEthClientDriftSeconds: 300,
       ethereumAllowNoDebugHosts: false,
+      skipHistoricalLogsCheck: false,
     },
     mapArchiverConfig(config),
   );
@@ -171,16 +174,22 @@ export async function createArchiver(
   return archiver;
 }
 
-/** Registers protocol contracts in the archiver store. */
+/** Registers protocol contracts in the archiver store. Idempotent — skips contracts that already exist (e.g. on node restart). */
 export async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();
     const contract = await provider.getProtocolContractArtifact(name);
-    const contractClassPublic: ContractClassPublic = {
+
+    // Skip if already registered (happens on node restart with a persisted store).
+    if (await store.getContractClass(contract.contractClass.id)) {
+      continue;
+    }
+
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(contract.contractClass.packedBytecode);
+    const contractClassPublic: ContractClassPublicWithCommitment = {
       ...contract.contractClass,
-      privateFunctions: [],
-      utilityFunctions: [],
+      publicBytecodeCommitment,
     };
 
     const publicFunctionSignatures = contract.artifact.functions
@@ -188,8 +197,7 @@ export async function registerProtocolContracts(store: KVArchiverDataStore) {
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
     await store.registerContractFunctionSignatures(publicFunctionSignatures);
-    const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
-    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], BlockNumber(blockNumber));
+    await store.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
     await store.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }

package/src/index.ts

@@ -10,4 +10,5 @@ export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './store/kv_archiver_st
 export { ContractInstanceStore } from './store/contract_instance_store.js';
 export { L2TipsCache } from './store/l2_tips_cache.js';
 
-export { retrieveCheckpointsFromRollup, retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';
+export { CalldataRetriever } from './l1/calldata_retriever.js';

package/src/l1/calldata_retriever.ts

@@ -1,6 +1,7 @@
 import { MULTI_CALL_3_ADDRESS, type ViemCommitteeAttestations, type ViemHeader } from '@aztec/ethereum/contracts';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { LruSet } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
@@ -44,7 +45,7 @@ type CheckpointData = {
  */
 export class CalldataRetriever {
   /** Tx hashes we've already logged for trace+debug failure (log once per tx per process). */
-  private static readonly traceFailureWarnedTxHashes = new Set<string>();
+  private static readonly traceFailureWarnedTxHashes = new LruSet<string>(1000);
 
   /** Clears the trace-failure warned set. For testing only. */
   static resetTraceFailureWarnedForTesting(): void {

package/src/l1/data_retrieval.ts

@@ -35,18 +35,28 @@ import type { DataRetrieval } from '../structs/data_retrieval.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
 import { CalldataRetriever } from './calldata_retriever.js';
 
-export type RetrievedCheckpoint = {
+type RetrievedCheckpointBase = {
   checkpointNumber: CheckpointNumber;
   archiveRoot: Fr;
   feeAssetPriceModifier: bigint;
   header: CheckpointHeader;
-  checkpointBlobData: CheckpointBlobData;
   l1: L1PublishedData;
   chainId: Fr;
   version: Fr;
   attestations: CommitteeAttestation[];
 };
 
+/** Checkpoint data as retrieved from L1 calldata and blob data. */
+export type RetrievedCheckpoint = RetrievedCheckpointBase & { checkpointBlobData: CheckpointBlobData };
+
+/** Checkpoint data retrieved from L1 calldata only, without blob data. */
+export type RetrievedCheckpointFromCalldata = RetrievedCheckpointBase & {
+  /** Versioned blob hashes from the checkpoint proposed event. */
+  blobHashes: Buffer[];
+  /** Parent beacon block root from the L1 block, used for blob fetching. */
+  parentBeaconBlockRoot: string | undefined;
+};
+
 export async function retrievedToPublishedCheckpoint({
   checkpointNumber,
   archiveRoot,
@@ -137,31 +147,27 @@ export async function retrievedToPublishedCheckpoint({
 }
 
 /**
- * Fetches new checkpoints.
+ * Fetches checkpoint calldata from the rollup contract without fetching blob data.
+ * Returns RetrievedCheckpointFromCalldata objects that preserve the information needed for deferred blob fetching.
  * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
- * @param blobClient - The blob client client for fetching blob data.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
  * @param instrumentation - The archiver instrumentation instance.
  * @param logger - The logger instance.
- * @param isHistoricalSync - Whether this is a historical sync.
- * @returns An array of retrieved checkpoints.
+ * @returns An array of calldata-only checkpoints.
  */
-export async function retrieveCheckpointsFromRollup(
+export async function retrieveCheckpointCalldataFromRollup(
   rollup: RollupContract,
   publicClient: ViemPublicClient,
   debugClient: ViemPublicDebugClient,
-  blobClient: BlobClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   instrumentation: ArchiverInstrumentation,
   logger: Logger = createLogger('archiver'),
-  isHistoricalSync: boolean = false,
-): Promise<RetrievedCheckpoint[]> {
-  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
+): Promise<RetrievedCheckpointFromCalldata[]> {
+  const retrievedCheckpoints: RetrievedCheckpointFromCalldata[] = [];
 
   let rollupConstants: { chainId: Fr; version: Fr; targetCommitteeSize: number } | undefined;
 
@@ -197,46 +203,39 @@ export async function retrieveCheckpointsFromRollup(
       rollup,
       publicClient,
       debugClient,
-      blobClient,
       checkpointProposedLogs,
       rollupConstants,
       instrumentation,
       logger,
-      isHistoricalSync,
     );
     retrievedCheckpoints.push(...newCheckpoints);
     searchStartBlock = lastLog.l1BlockNumber + 1n;
   } while (searchStartBlock <= searchEndBlock);
 
-  // The asyncPool from processCheckpointProposedLogs will not necessarily return the checkpoints in order, so we sort them before returning.
   return retrievedCheckpoints.sort((a, b) => Number(a.l1.blockNumber - b.l1.blockNumber));
 }
 
 /**
- * Processes newly received CheckpointProposed logs.
+ * Processes CheckpointProposed logs, fetching only calldata (no blobs).
  * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
- * @param blobClient - The blob client client for fetching blob data.
  * @param logs - CheckpointProposed logs.
  * @param rollupConstants - The rollup constants (chainId, version, targetCommitteeSize).
  * @param instrumentation - The archiver instrumentation instance.
  * @param logger - The logger instance.
- * @param isHistoricalSync - Whether this is a historical sync.
- * @returns An array of retrieved checkpoints.
+ * @returns An array of calldata-only checkpoints.
  */
 async function processCheckpointProposedLogs(
   rollup: RollupContract,
   publicClient: ViemPublicClient,
   debugClient: ViemPublicDebugClient,
-  blobClient: BlobClientInterface,
   logs: CheckpointProposedLog[],
   { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
   instrumentation: ArchiverInstrumentation,
   logger: Logger,
-  isHistoricalSync: boolean,
-): Promise<RetrievedCheckpoint[]> {
-  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
+): Promise<RetrievedCheckpointFromCalldata[]> {
+  const retrievedCheckpoints: RetrievedCheckpointFromCalldata[] = [];
   const calldataRetriever = new CalldataRetriever(
     publicClient,
     debugClient,
@@ -252,7 +251,6 @@ async function processCheckpointProposedLogs(
     const archiveFromChain = await rollup.archiveAt(checkpointNumber);
     const blobHashes = log.args.versionedBlobHashes;
 
-    // The value from the event and contract will match only if the checkpoint is in the chain.
     if (archive.equals(archiveFromChain)) {
       const expectedHashes = {
         attestationsHash: log.args.attestationsHash.toString() as Hex,
@@ -268,19 +266,16 @@ async function processCheckpointProposedLogs(
       const { timestamp, parentBeaconBlockRoot } = await getL1Block(publicClient, log.l1BlockNumber);
       const l1 = new L1PublishedData(log.l1BlockNumber, timestamp, log.l1BlockHash.toString());
 
-      const checkpointBlobData = await getCheckpointBlobDataFromBlobs(
-        blobClient,
-        checkpoint.blockHash,
+      retrievedCheckpoints.push({
+        ...checkpoint,
+        l1,
+        chainId,
+        version,
         blobHashes,
-        checkpointNumber,
-        logger,
-        isHistoricalSync,
         parentBeaconBlockRoot,
-        timestamp,
-      );
+      });
 
-      retrievedCheckpoints.push({ ...checkpoint, checkpointBlobData, l1, chainId, version });
-      logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.l1TransactionHash}`, {
+      logger.trace(`Retrieved checkpoint calldata ${checkpointNumber} from L1 tx ${log.l1TransactionHash}`, {
         l1BlockNumber: log.l1BlockNumber,
         checkpointNumber,
         archive: archive.toString(),
@@ -344,14 +339,10 @@ export async function getCheckpointBlobDataFromBlobs(
 /** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
 export async function retrieveL1ToL2Message(
   inbox: InboxContract,
-  leaf: Fr,
-  fromBlock: bigint,
-  toBlock: bigint,
+  message: InboxMessage,
 ): Promise<InboxMessage | undefined> {
-  const logs = await inbox.getMessageSentEventByHash(leaf.toString(), fromBlock, toBlock);
-
-  const messages = mapLogsInboxMessage(logs);
-  return messages.length > 0 ? messages[0] : undefined;
+  const log = await inbox.getMessageSentEventByHash(message.leaf.toString(), message.l1BlockNumber);
+  return log && mapLogInboxMessage(log);
 }
 
 /**
@@ -374,22 +365,22 @@ export async function retrieveL1ToL2Messages(
       break;
     }
 
-    retrievedL1ToL2Messages.push(...mapLogsInboxMessage(messageSentLogs));
+    retrievedL1ToL2Messages.push(...messageSentLogs.map(mapLogInboxMessage));
     searchStartBlock = messageSentLogs.at(-1)!.l1BlockNumber + 1n;
   }
 
   return retrievedL1ToL2Messages;
 }
 
-function mapLogsInboxMessage(logs: MessageSentLog[]): InboxMessage[] {
-  return logs.map(log => ({
+function mapLogInboxMessage(log: MessageSentLog): InboxMessage {
+  return {
     index: log.args.index,
     leaf: log.args.leaf,
     l1BlockNumber: log.l1BlockNumber,
     l1BlockHash: log.l1BlockHash,
     checkpointNumber: log.args.checkpointNumber,
     rollingHash: log.args.rollingHash,
-  }));
+  };
 }
 
 /** Retrieves L2ProofVerified events from the rollup contract. */

package/src/l1/validate_historical_logs.ts

@@ -0,0 +1,140 @@
+import { getPublicClient, getRpcUrlsFromClient } from '@aztec/ethereum/client';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+
+/** Subset of L1 contract addresses whose historical logs the Aztec node relies on. */
+export type HistoricalLogsContractAddresses = Pick<
+  L1ContractAddresses,
+  'rollupAddress' | 'inboxAddress' | 'registryAddress' | 'governanceProposerAddress'
+>;
+
+/** Result of probing a single RPC URL. */
+type ProbeResult = { ok: true } | { ok: false; reason: string; clientVersion: string | undefined };
+
+/**
+ * Validates that every configured L1 RPC URL returns historical logs for the Rollup contract.
+ *
+ * Some RPC providers prune old logs, which would cause L1 syncing to silently fail. To detect this,
+ * we query for the `OwnershipTransferred` event which every Rollup emits in its constructor (via
+ * Ownable) on the block it was deployed (`l1StartBlock`). The `client` is typically a viem fallback
+ * transport over several user-configured RPC URLs — checking only the first URL would miss a bad
+ * secondary, so we probe each URL independently. The first URL that fails aborts startup, unless
+ * the operator has explicitly opted out.
+ *
+ * @param client - The L1 public client built from the user-configured RPC URLs.
+ * @param addresses - The subset of L1 contract addresses we rely on for historical log retrieval.
+ * @param skipCheck - If true, log warnings instead of throwing.
+ * @param bindings - Optional logger bindings for context.
+ * @throws Error if any URL fails the probe and skipCheck is false.
+ */
+export async function validateAndLogHistoricalLogsAvailability(
+  client: ViemPublicClient,
+  addresses: HistoricalLogsContractAddresses,
+  skipCheck: boolean,
+  bindings?: LoggerBindings,
+): Promise<void> {
+  const logger = createLogger('archiver:validate_historical_logs', bindings);
+  logger.debug('Validating historical log availability on L1 RPCs');
+
+  const urls = getRpcUrlsFromClient(client);
+  if (urls.length === 0) {
+    logger.warn('Could not determine L1 RPC URLs from the public client; skipping historical logs check.');
+    return;
+  }
+
+  const chainId = client.chain?.id;
+  if (chainId === undefined) {
+    logger.warn('Could not determine L1 chain ID from the public client; skipping historical logs check.');
+    return;
+  }
+
+  for (const url of urls) {
+    const probeClient = getPublicClient({ l1RpcUrls: [url], l1ChainId: chainId });
+    const rollup = new RollupContract(probeClient, addresses.rollupAddress.toString());
+    const result = await probeRpcUrl(rollup, probeClient, logger);
+
+    if (result.ok) {
+      logger.debug(`L1 RPC ${url} returned historical OwnershipTransferred log for the Rollup contract.`);
+      continue;
+    }
+
+    const errorMessage = buildErrorMessage(url, result, addresses);
+    if (skipCheck) {
+      logger.warn(`${errorMessage}\nContinuing because ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK is true.`);
+      continue;
+    }
+
+    logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+
+/** Runs the OwnershipTransferred probe against a single RPC and queries its client version. */
+async function probeRpcUrl(rollup: RollupContract, client: ViemPublicClient, logger: Logger): Promise<ProbeResult> {
+  let queryError: unknown;
+  try {
+    const logs = await rollup.getOwnershipTransferredEventsAtDeploy();
+    if (logs.length > 0) {
+      return { ok: true };
+    }
+  } catch (err) {
+    queryError = err;
+  }
+
+  const clientVersion = await getClientVersion(client, logger);
+
+  let reason: string;
+  if (queryError instanceof Error) {
+    reason = `Query for historical logs failed: ${queryError.message}`;
+  } else if (queryError !== undefined) {
+    reason = 'Query for historical logs failed with a non-Error value.';
+  } else {
+    reason = 'No OwnershipTransferred event was returned by the L1 RPC for the Rollup deploy block.';
+  }
+  return { ok: false, reason, clientVersion };
+}
+
+/** Builds the operator-facing error message for a failing RPC URL. */
+function buildErrorMessage(
+  url: string,
+  result: Extract<ProbeResult, { ok: false }>,
+  addresses: HistoricalLogsContractAddresses,
+): string {
+  return [
+    `L1 RPC at ${url} does not return historical logs for the Rollup contract. ${result.reason}`,
+    `This likely means this Ethereum RPC node prunes old logs, which would cause the archiver ` +
+      `to silently miss data during L1 sync.`,
+    result.clientVersion
+      ? `Detected L1 client version for ${url}: ${result.clientVersion}.`
+      : `Could not determine L1 client version for ${url}.`,
+    `The following L1 contract addresses must have their historical logs retained by the RPC node:`,
+    `  - Rollup:             ${addresses.rollupAddress.toString()}`,
+    `  - Inbox:              ${addresses.inboxAddress.toString()}`,
+    `  - Registry:           ${addresses.registryAddress.toString()}`,
+    `  - GovernanceProposer: ${addresses.governanceProposerAddress.toString()}`,
+    isReth(result.clientVersion)
+      ? `To retain logs for these contracts, configure reth with a ` +
+        `prune.segments.receipts_log_filter entry for each address above ` +
+        `so reth does not prune their receipts/logs. See https://reth.rs/run/pruning.html for details.`
+      : `Point this RPC endpoint at a node that retains full log history for the addresses above.`,
+    `Set ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK=true to bypass this check at your own risk.`,
+  ].join('\n');
+}
+
+/** Queries `web3_clientVersion` on the L1 RPC. Returns undefined if the call fails or returns a non-string. */
+async function getClientVersion(client: ViemPublicClient, logger: Logger): Promise<string | undefined> {
+  try {
+    const result = await client.request({ method: 'web3_clientVersion' });
+    return typeof result === 'string' ? result : undefined;
+  } catch (err) {
+    logger.debug(`Failed to query web3_clientVersion: ${err instanceof Error ? err.message : err}`);
+    return undefined;
+  }
+}
+
+/** Heuristic check for reth based on the web3_clientVersion string (reth returns e.g. "reth/v1.0.0-..."). */
+function isReth(clientVersion: string | undefined): boolean {
+  return !!clientVersion && /reth/i.test(clientVersion);
+}

package/src/modules/data_source_base.ts

@@ -6,7 +6,13 @@ import { isDefined } from '@aztec/foundation/types';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type BlockData, type BlockHash, CheckpointedL2Block, L2Block, type L2Tips } from '@aztec/stdlib/block';
-import { Checkpoint, type CheckpointData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import {
+  Checkpoint,
+  type CheckpointData,
+  type CommonCheckpointData,
+  type ProposedCheckpointData,
+  PublishedCheckpoint,
+} from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
@@ -154,7 +160,15 @@ export abstract class ArchiverDataSourceBase
   }
 
   public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return this.store.getSettledTxReceipt(txHash);
+    return this.store.getSettledTxReceipt(txHash, this.l1Constants);
+  }
+
+  public getProposedCheckpoint(): Promise<CommonCheckpointData | undefined> {
+    return this.store.getProposedCheckpoint();
+  }
+
+  public getProposedCheckpointOnly(): Promise<ProposedCheckpointData | undefined> {
+    return this.store.getProposedCheckpointOnly();
   }
 
   public isPendingChainInvalid(): Promise<boolean> {
@@ -165,16 +179,21 @@ export abstract class ArchiverDataSourceBase
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
-  public getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
-    return this.store.getPrivateLogsByTags(tags, page);
+  public getPrivateLogsByTags(
+    tags: SiloedTag[],
+    page?: number,
+    upToBlockNumber?: BlockNumber,
+  ): Promise<TxScopedL2Log[][]> {
+    return this.store.getPrivateLogsByTags(tags, page, upToBlockNumber);
   }
 
   public getPublicLogsByTagsFromContract(
     contractAddress: AztecAddress,
     tags: Tag[],
     page?: number,
+    upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]> {
-    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page);
+    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
   }
 
   public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {