@aztec/archiver 0.76.4 → 0.77.0-testnet-ignition.21

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -1,6 +1,6 @@
-import { InboxLeaf } from '@aztec/circuit-types';
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
-import { type Fr } from '@aztec/foundation/fields';
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
 
 /**
  * A simple in-memory implementation of an L1 to L2 message store.

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,45 +1,43 @@
 import {
-  type ContractClass2BlockL2Logs,
-  ExtendedPublicLog,
-  ExtendedUnencryptedL2Log,
-  type GetContractClassLogsResponse,
-  type GetPublicLogsResponse,
-  type InBlock,
-  type InboxLeaf,
-  type L2Block,
-  L2BlockHash,
-  type LogFilter,
-  LogId,
-  type TxEffect,
-  type TxHash,
-  TxReceipt,
-  TxScopedL2Log,
-  wrapInBlock,
-} from '@aztec/circuit-types';
-import {
-  type BlockHeader,
-  type ContractClassPublic,
-  type ContractClassPublicWithBlockNumber,
-  type ContractInstanceWithAddress,
-  type ExecutablePrivateFunctionWithMembershipProof,
-  Fr,
   INITIAL_L2_BLOCK_NUM,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type InBlock, type L2Block, L2BlockHash, wrapInBlock } from '@aztec/stdlib/block';
+import type {
+  ContractClassPublic,
+  ContractClassPublicWithBlockNumber,
+  ContractInstanceUpdateWithAddress,
+  ContractInstanceWithAddress,
+  ExecutablePrivateFunctionWithMembershipProof,
+  UnconstrainedFunctionWithMembershipProof,
+} from '@aztec/stdlib/contract';
+import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
+import {
+  ContractClassLog,
+  ExtendedContractClassLog,
+  ExtendedPublicLog,
+  type LogFilter,
+  LogId,
   type PrivateLog,
   type PublicLog,
-  type UnconstrainedFunctionWithMembershipProof,
-} from '@aztec/circuits.js';
-import { FunctionSelector } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { createLogger } from '@aztec/foundation/log';
+  TxScopedL2Log,
+} from '@aztec/stdlib/logs';
+import type { InboxLeaf } from '@aztec/stdlib/messaging';
+import { type BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
-import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval } from '../structs/data_retrieval.js';
-import { type L1Published } from '../structs/published.js';
+import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
+import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { L1Published } from '../structs/published.js';
 import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
+type StoredContractInstanceUpdate = ContractInstanceUpdateWithAddress & { blockNumber: number; logIndex: number };
+
 /**
  * Simple, in-memory implementation of an archiver data store.
  */
@@ -62,7 +60,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private publicLogsPerBlock: Map<number, PublicLog[]> = new Map();
 
-  private contractClassLogsPerBlock: Map<number, ContractClass2BlockL2Logs> = new Map();
+  private contractClassLogsPerBlock: Map<number, ContractClassLog[]> = new Map();
 
   private blockScopedNullifiers: Map<string, { blockNumber: number; blockHash: string; index: bigint }> = new Map();
 
@@ -81,7 +79,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
 
+  private contractInstanceUpdates: Map<string, StoredContractInstanceUpdate[]> = new Map();
+
   private lastL1BlockNewBlocks: bigint | undefined = undefined;
+
   private lastL1BlockNewMessages: bigint | undefined = undefined;
 
   private lastProvenL2BlockNumber: number = 0;
@@ -112,7 +113,23 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return Promise.resolve(this.contractInstances.get(address.toString()));
+    const instance = this.contractInstances.get(address.toString());
+    if (!instance) {
+      return Promise.resolve(undefined);
+    }
+    const updates = this.contractInstanceUpdates.get(address.toString()) || [];
+    if (updates.length > 0) {
+      const lastUpdate = updates[0];
+      const currentBlockNumber = this.getLastBlockNumber();
+      if (currentBlockNumber >= lastUpdate.blockOfChange) {
+        instance.currentContractClassId = lastUpdate.newContractClassId;
+      } else if (!lastUpdate.prevContractClassId.isZero()) {
+        instance.currentContractClassId = lastUpdate.prevContractClassId;
+      } else {
+        instance.currentContractClassId = instance.originalContractClassId;
+      }
+    }
+    return Promise.resolve(instance);
   }
 
   public getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
@@ -186,6 +203,33 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
+  public addContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], blockNumber: number): Promise<boolean> {
+    for (let logIndex = 0; logIndex < data.length; logIndex++) {
+      const contractInstanceUpdate = data[logIndex];
+      const updates = this.contractInstanceUpdates.get(contractInstanceUpdate.address.toString()) || [];
+      updates.unshift({
+        ...contractInstanceUpdate,
+        blockNumber,
+        logIndex,
+      });
+      this.contractInstanceUpdates.set(contractInstanceUpdate.address.toString(), updates);
+    }
+    return Promise.resolve(true);
+  }
+
+  public deleteContractInstanceUpdates(
+    data: ContractInstanceUpdateWithAddress[],
+    blockNumber: number,
+  ): Promise<boolean> {
+    for (let logIndex = 0; logIndex < data.length; logIndex++) {
+      const contractInstanceUpdate = data[logIndex];
+      let updates = this.contractInstanceUpdates.get(contractInstanceUpdate.address.toString()) || [];
+      updates = updates.filter(update => !(update.blockNumber === blockNumber && update.logIndex === logIndex));
+      this.contractInstanceUpdates.set(contractInstanceUpdate.address.toString(), updates);
+    }
+    return Promise.resolve(true);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
@@ -306,7 +350,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       this.#storeTaggedLogsFromPublic(block);
       this.privateLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.privateLogs).flat());
       this.publicLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.publicLogs).flat());
-      this.contractClassLogsPerBlock.set(block.number, block.body.contractClassLogs);
+      this.contractClassLogsPerBlock.set(
+        block.number,
+        block.body.txEffects.map(txEffect => txEffect.contractClassLogs).flat(),
+      );
     });
     return Promise.resolve(true);
   }
@@ -654,34 +701,36 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
     const contractAddress = filter.contractAddress;
 
-    const logs: ExtendedUnencryptedL2Log[] = [];
+    const logs: ExtendedContractClassLog[] = [];
 
     for (; fromBlock < toBlock; fromBlock++) {
       const block = this.l2Blocks[fromBlock - INITIAL_L2_BLOCK_NUM];
       const blockLogs = this.contractClassLogsPerBlock.get(fromBlock);
 
       if (blockLogs) {
-        for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-          const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
-          for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-            const log = txLogs[logIndexInTx];
-            if (
-              (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
-              (!contractAddress || log.contractAddress.equals(contractAddress))
-            ) {
-              logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
-              if (logs.length === this.maxLogs) {
-                return Promise.resolve({
-                  logs,
-                  maxLogsHit: true,
-                });
-              }
+        for (let logIndex = 0; logIndex < blockLogs.length; logIndex++) {
+          const log = blockLogs[logIndex];
+          const thisTxEffect = block.data.body.txEffects.filter(effect => effect.contractClassLogs.includes(log))[0];
+          const thisTxIndexInBlock = block.data.body.txEffects.indexOf(thisTxEffect);
+          const thisLogIndexInTx = thisTxEffect.contractClassLogs.indexOf(log);
+          if (
+            (!txHash || thisTxEffect.txHash.equals(txHash)) &&
+            (!contractAddress || log.contractAddress.equals(contractAddress)) &&
+            thisTxIndexInBlock >= txIndexInBlock &&
+            thisLogIndexInTx >= logIndexInTx
+          ) {
+            logs.push(
+              new ExtendedContractClassLog(new LogId(block.data.number, thisTxIndexInBlock, thisLogIndexInTx), log),
+            );
+            if (logs.length === this.maxLogs) {
+              return Promise.resolve({
+                logs,
+                maxLogsHit: true,
+              });
             }
           }
-          logIndexInTx = 0;
         }
       }
-      txIndexInBlock = 0;
     }
 
     return Promise.resolve({
@@ -690,15 +739,19 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     });
   }
 
+  getLastBlockNumber(): number {
+    if (this.l2Blocks.length === 0) {
+      return INITIAL_L2_BLOCK_NUM - 1;
+    }
+    return this.l2Blocks[this.l2Blocks.length - 1].data.number;
+  }
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
   public getSynchedL2BlockNumber(): Promise<number> {
-    if (this.l2Blocks.length === 0) {
-      return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
-    }
-    return Promise.resolve(this.l2Blocks[this.l2Blocks.length - 1].data.number);
+    return Promise.resolve(this.getLastBlockNumber());
   }
 
   public getProvenL2BlockNumber(): Promise<number> {

package/src/factory.ts

@@ -1,51 +1,70 @@
-import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import { type ArchiverApi, type Service, getComponentsVersionsFromConfig } from '@aztec/circuit-types';
-import {
-  type ContractClassPublic,
-  computePublicBytecodeCommitment,
-  getContractClassFromArtifact,
-} from '@aztec/circuits.js';
-import { FunctionType, decodeFunctionSignature } from '@aztec/foundation/abi';
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { createLogger } from '@aztec/foundation/log';
-import { type Maybe } from '@aztec/foundation/types';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractNames, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { getCanonicalProtocolContract } from '@aztec/protocol-contracts/bundle';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
+import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import {
+  type ContractClassPublic,
+  computePublicBytecodeCommitment,
+  getContractClassFromArtifact,
+} from '@aztec/stdlib/contract';
+import type { ArchiverApi, Service } from '@aztec/stdlib/interfaces/server';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { Archiver } from './archiver/archiver.js';
-import { type ArchiverConfig } from './archiver/config.js';
+import type { ArchiverConfig } from './archiver/config.js';
 import { KVArchiverDataStore } from './archiver/index.js';
 import { createArchiverClient } from './rpc/index.js';
 
+/**
+ * Creates a local archiver.
+ * @param config - The archiver configuration.
+ * @param blobSinkClient - The blob sink client.
+ * @param opts - The options.
+ * @param telemetry - The telemetry client.
+ * @returns The local archiver.
+ */
 export async function createArchiver(
   config: ArchiverConfig & DataStoreConfig,
   blobSinkClient: BlobSinkClientInterface,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
   telemetry: TelemetryClient = getTelemetryClient(),
-): Promise<ArchiverApi & Maybe<Service>> {
+): Promise<ArchiverApi & Service & L2BlockSourceEventEmitter> {
+  const store = await createStore('archiver', config, createLogger('archiver:lmdb'));
+  const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
+  await registerProtocolContracts(archiverStore);
+  await registerCommonContracts(archiverStore);
+  return Archiver.createAndSync(config, archiverStore, { telemetry, blobSinkClient }, opts.blockUntilSync);
+}
+
+/**
+ * Creates a remote archiver client.
+ * @param config - The archiver configuration.
+ * @returns The remote archiver client.
+ */
+export function createRemoteArchiver(config: ArchiverConfig): ArchiverApi {
   if (!config.archiverUrl) {
-    const store = await createStore('archiver', config, createLogger('archiver:lmdb'));
-    const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
-    await registerProtocolContracts(archiverStore);
-    await registerCommonContracts(archiverStore);
-    return Archiver.createAndSync(config, archiverStore, { telemetry, blobSinkClient }, opts.blockUntilSync);
-  } else {
-    return createArchiverClient(
-      config.archiverUrl,
-      getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot()),
-    );
+    throw new Error('Archiver URL is required');
   }
+
+  return createArchiverClient(
+    config.archiverUrl,
+    getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot()),
+  );
 }
 
 async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
-    const contract = await getCanonicalProtocolContract(name);
+    const provider = new BundledProtocolContractsProvider();
+    const contract = await provider.getProtocolContractArtifact(name);
     const contractClassPublic: ContractClassPublic = {
       ...contract.contractClass,
       privateFunctions: [],

package/src/rpc/index.ts

@@ -1,10 +1,6 @@
-import {
-  type ArchiverApi,
-  ArchiverApiSchema,
-  type ComponentsVersions,
-  getVersioningResponseHandler,
-} from '@aztec/circuit-types';
 import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { type ArchiverApi, ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
+import { type ComponentsVersions, getVersioningResponseHandler } from '@aztec/stdlib/versioning';
 import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
 
 export function createArchiverClient(

package/src/test/mock_archiver.ts

@@ -1,5 +1,6 @@
-import { type L1ToL2MessageSource, type L2Block, type L2BlockSource } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 import { MockL1ToL2MessageSource } from './mock_l1_to_l2_message_source.js';
 import { MockL2BlockSource } from './mock_l2_block_source.js';

package/src/test/mock_l1_to_l2_message_source.ts

@@ -1,5 +1,5 @@
-import { type L1ToL2MessageSource } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
+import type { Fr } from '@aztec/foundation/fields';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
 /**
  * A mocked implementation of L1ToL2MessageSource to be used in tests.

package/src/test/mock_l2_block_source.ts

@@ -1,17 +1,9 @@
-import {
-  type L1RollupConstants,
-  L2Block,
-  L2BlockHash,
-  type L2BlockSource,
-  type L2Tips,
-  type TxHash,
-  TxReceipt,
-  TxStatus,
-  getSlotRangeForEpoch,
-} from '@aztec/circuit-types';
-import { type BlockHeader, EthAddress } from '@aztec/circuits.js';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
+import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
+import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
@@ -172,9 +164,18 @@ export class MockL2BlockSource implements L2BlockSource {
     const finalizedBlock = this.l2Blocks[finalized - 1];
 
     return {
-      latest: { number: latest, hash: (await latestBlock?.hash())?.toString() },
-      proven: { number: proven, hash: (await provenBlock?.hash())?.toString() },
-      finalized: { number: finalized, hash: (await finalizedBlock?.hash())?.toString() },
+      latest: {
+        number: latest,
+        hash: (await latestBlock?.hash())?.toString(),
+      },
+      proven: {
+        number: proven,
+        hash: (await provenBlock?.hash())?.toString(),
+      },
+      finalized: {
+        number: finalized,
+        hash: (await finalizedBlock?.hash())?.toString(),
+      },
     };
   }