@aztec/stdlib 2.0.0-rc.25 → 2.0.0-rc.27

package/src/block/validate_block_result.ts

@@ -0,0 +1,122 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { BlockInfoSchema, type L2BlockInfo, deserializeBlockInfo, serializeBlockInfo } from './l2_block_info.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/** Subtype for invalid block validation results */
+export type ValidateBlockNegativeResult =
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: bigint;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: not enough attestations were posted */
+      reason: 'insufficient-attestations';
+    }
+  | {
+      valid: false;
+      /** Identifiers from the invalid block */
+      block: L2BlockInfo;
+      /** Committee members at the epoch this block was proposed */
+      committee: EthAddress[];
+      /** Epoch in which this block was proposed */
+      epoch: bigint;
+      /** Proposer selection seed for the epoch */
+      seed: bigint;
+      /** List of committee members who signed this block proposal */
+      attestors: EthAddress[];
+      /** Committee attestations for this block as they were posted to L1 */
+      attestations: CommitteeAttestation[];
+      /** Reason for the block being invalid: an invalid attestation was posted */
+      reason: 'invalid-attestation';
+      /** Index in the attestations array of the invalid attestation posted */
+      invalidIndex: number;
+    };
+
+/** Result type for validating a block attestations */
+export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+
+export const ValidateBlockResultSchema = z.union([
+  z.object({ valid: z.literal(true) }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('insufficient-attestations'),
+  }),
+  z.object({
+    valid: z.literal(false),
+    block: BlockInfoSchema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestors: z.array(schemas.EthAddress),
+    attestations: z.array(CommitteeAttestation.schema),
+    reason: z.literal('invalid-attestation'),
+    invalidIndex: z.number(),
+  }),
+]) satisfies ZodFor<ValidateBlockResult>;
+
+export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
+  if (result.valid) {
+    return serializeToBuffer(true);
+  }
+
+  const l2Block = serializeBlockInfo(result.block);
+  return serializeToBuffer(
+    result.valid,
+    result.reason,
+    l2Block.length,
+    l2Block,
+    result.committee.length,
+    result.committee,
+    result.epoch,
+    result.seed ?? 0n,
+    result.attestors.length,
+    result.attestors,
+    result.attestations.length,
+    result.attestations,
+    result.reason === 'invalid-attestation' ? result.invalidIndex : 0,
+  );
+}
+
+export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferReader): ValidateBlockResult {
+  const reader = BufferReader.asReader(bufferOrReader);
+  const valid = reader.readBoolean();
+  if (valid) {
+    return { valid };
+  }
+  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
+  const block = deserializeBlockInfo(reader.readBuffer());
+  const committee = reader.readVector(EthAddress);
+  const epoch = reader.readBigInt();
+  const seed = reader.readBigInt();
+  const attestors = reader.readVector(EthAddress);
+  const attestations = reader.readVector(CommitteeAttestation);
+  const invalidIndex = reader.readNumber();
+  if (reason === 'insufficient-attestations') {
+    return { valid, reason, block, committee, epoch, seed, attestors, attestations: attestations };
+  } else if (reason === 'invalid-attestation') {
+    return { valid, reason, block, committee, epoch, seed, attestors, invalidIndex, attestations: attestations };
+  } else {
+    const _: never = reason;
+    throw new Error(`Unknown reason: ${reason}`);
+  }
+}

package/src/interfaces/archiver.ts

@@ -1,10 +1,12 @@
+import type { L1ContractAddresses } from '@aztec/ethereum';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 import { L2Block } from '../block/l2_block.js';
-import { type L2BlockSource, L2TipsSchema, ValidateBlockResultSchema } from '../block/l2_block_source.js';
+import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
+import { ValidateBlockResultSchema } from '../block/validate_block_result.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
@@ -23,6 +25,41 @@ import { TxReceipt } from '../tx/tx_receipt.js';
 import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
 import type { L2LogsSource } from './l2_logs_source.js';
 
+/**
+ * The archiver configuration.
+ */
+export type ArchiverSpecificConfig = {
+  /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
+  archiverPollingIntervalMS?: number;
+
+  /** The number of L2 blocks the archiver will attempt to download at a time. */
+  archiverBatchSize?: number;
+
+  /** The polling interval viem uses in ms */
+  viemPollingIntervalMS?: number;
+
+  /** The deployed L1 contract addresses */
+  l1Contracts: L1ContractAddresses;
+
+  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
+  maxLogs?: number;
+
+  /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKB. */
+  archiverStoreMapSizeKb?: number;
+
+  /** Whether to skip validating block attestations (use only for testing). */
+  skipValidateBlockAttestations?: boolean;
+};
+
+export const ArchiverSpecificConfigSchema = z.object({
+  archiverPollingIntervalMS: schemas.Integer.optional(),
+  archiverBatchSize: schemas.Integer.optional(),
+  viemPollingIntervalMS: schemas.Integer.optional(),
+  maxLogs: schemas.Integer.optional(),
+  archiverStoreMapSizeKb: schemas.Integer.optional(),
+  skipValidateBlockAttestations: z.boolean().optional(),
+});
+
 export type ArchiverApi = Omit<
   L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource,
   'start' | 'stop'

package/src/interfaces/aztec-node-admin.ts

@@ -5,6 +5,7 @@ import { z } from 'zod';
 import type { ApiSchemaFor } from '../schemas/schemas.js';
 import { type Offense, OffenseSchema, type SlashPayloadRound, SlashPayloadRoundSchema } from '../slashing/index.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
+import { type ArchiverSpecificConfig, ArchiverSpecificConfigSchema } from './archiver.js';
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
 import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
 import { type SlasherConfig, SlasherConfigSchema } from './slasher.js';
@@ -54,11 +55,21 @@ export interface AztecNodeAdmin {
 export type AztecNodeAdminConfig = ValidatorClientFullConfig &
   SequencerConfig &
   ProverConfig &
-  SlasherConfig & { maxTxPoolSize: number };
+  SlasherConfig &
+  Pick<ArchiverSpecificConfig, 'archiverPollingIntervalMS' | 'skipValidateBlockAttestations' | 'archiverBatchSize'> & {
+    maxTxPoolSize: number;
+  };
 
 export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
   .merge(SlasherConfigSchema)
   .merge(ValidatorClientConfigSchema)
+  .merge(
+    ArchiverSpecificConfigSchema.pick({
+      archiverPollingIntervalMS: true,
+      skipValidateBlockAttestations: true,
+      archiverBatchSize: true,
+    }),
+  )
   .merge(z.object({ maxTxPoolSize: z.number() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {

package/src/interfaces/block-builder.ts

@@ -2,6 +2,8 @@ import type { Fr } from '@aztec/foundation/fields';
 import type { Timer } from '@aztec/foundation/timer';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { ChainConfig, SequencerConfig } from '../config/chain-config.js';
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import type { Gas } from '../gas/gas.js';
 import type { MerkleTreeWriteOperations } from '../trees/index.js';
 import type { BlockHeader } from '../tx/block_header.js';
@@ -59,13 +61,14 @@ export interface BuildBlockResult {
   usedTxs: Tx[];
 }
 
+export type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'> &
+  Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
+  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'fakeProcessingDelayPerTxMs'>;
+
 export interface IFullNodeBlockBuilder {
-  getConfig(): {
-    l1GenesisTime: bigint;
-    slotDuration: number;
-    l1ChainId: number;
-    rollupVersion: number;
-  };
+  getConfig(): FullNodeBlockBuilderConfig;
+
+  updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
 
   buildBlock(
     txs: Iterable<Tx> | AsyncIterable<Tx>,

package/src/p2p/block_attestation.ts

@@ -98,6 +98,10 @@ export class BlockAttestation extends Gossipable {
     return new BlockAttestation(0, ConsensusPayload.empty(), Signature.empty());
   }
 
+  static random(): BlockAttestation {
+    return new BlockAttestation(Math.floor(Math.random() * 1000) + 1, ConsensusPayload.random(), Signature.random());
+  }
+
   getSize(): number {
     return 4 /* blockNumber */ + this.payload.getSize() + this.signature.getSize();
   }

package/src/p2p/block_proposal.ts

@@ -5,7 +5,7 @@ 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 type { L2BlockInfo } from '../block/l2_block_info.js';
 import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
@@ -71,11 +71,13 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  toBlockInfo(): BlockInfo {
+  toBlockInfo(): L2BlockInfo {
     return {
       blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
-      archive: this.archive.toString(),
+      lastArchive: this.payload.header.lastArchiveRoot,
+      timestamp: this.payload.header.timestamp,
+      archive: this.archive,
       txCount: this.txHashes.length,
     };
   }

package/src/p2p/consensus_payload.ts

@@ -60,18 +60,17 @@ export class ConsensusPayload implements Signable {
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.stateReference]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive, this.stateReference]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
+    const payload = new ConsensusPayload(
       reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
     );
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
@@ -86,6 +85,10 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
   }
 
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(ProposedBlockHeader.random(), Fr.random(), StateReference.random());
+  }
+
   /**
    * Get the size of the consensus payload in bytes.
    * @returns The size of the consensus payload.

package/src/tests/mocks.ts

@@ -6,9 +6,9 @@ import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CommitteeAttestation } from '../block/index.js';
+import { CommitteeAttestation, L1PublishedData } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
-import type { PublishedL2Block } from '../block/published_l2_block.js';
+import { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
@@ -306,16 +306,16 @@ export async function randomPublishedL2Block(
   opts: { signers?: Secp256k1Signer[] } = {},
 ): Promise<PublishedL2Block> {
   const block = await L2Block.random(l2BlockNumber);
-  const l1 = {
+  const l1 = L1PublishedData.fromFields({
     blockNumber: BigInt(block.number),
     timestamp: block.header.globalVariables.timestamp,
     blockHash: Buffer32.random().toString(),
-  };
+  });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
   const atts = await Promise.all(signers.map(signer => makeBlockAttestationFromBlock(block, signer)));
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );
-  return { block, l1, attestations };
+  return new PublishedL2Block(block, l1, attestations);
 }

package/src/tx/content_commitment.ts

@@ -75,6 +75,10 @@ export class ContentCommitment {
     return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
   }
 
+  static random(): ContentCommitment {
+    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
+  }
+
   static empty(): ContentCommitment {
     return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
   }

package/src/tx/partial_state_reference.ts

@@ -64,6 +64,14 @@ export class PartialStateReference {
     );
   }
 
+  static random(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    );
+  }
+
   toViem(): ViemPartialStateReference {
     return {
       noteHashTree: this.noteHashTree.toViem(),

package/src/tx/proposed_block_header.ts

@@ -116,6 +116,19 @@ export class ProposedBlockHeader {
     });
   }
 
+  static random(): ProposedBlockHeader {
+    return new ProposedBlockHeader(
+      Fr.random(),
+      ContentCommitment.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
+      BigInt(Math.floor(Date.now() / 1000)),
+      EthAddress.random(),
+      new AztecAddress(Fr.random()),
+      GasFees.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.lastArchiveRoot.isZero() &&

package/src/tx/state_reference.ts

@@ -78,6 +78,10 @@ export class StateReference {
     return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
   }
 
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
   toViem(): ViemStateReference {
     return {
       l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),