@aztec/stdlib 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/src/aztec-address/index.ts

@@ -1,17 +1,12 @@
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-import { Fr, Point, fromBuffer } from '@aztec/foundation/fields';
+import { Fr, fromBuffer } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { type ZodFor, bufferSchemaFor, hexSchemaFor } from '@aztec/foundation/schemas';
-import { type BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { type BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
-/** Branding to ensure fields are not interchangeable types. */
-export interface AztecAddress {
-  /** Brand. */
-  _branding: 'AztecAddress';
-}
 /**
  * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
  * compare addresses, as well as conversion to and from strings, buffers, and other formats.
@@ -22,6 +17,9 @@ export interface AztecAddress {
  * wild.
  */
 export class AztecAddress {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'AztecAddress';
+
   private xCoord: Fr;
 
   constructor(buffer: Buffer | Fr) {
@@ -164,6 +162,3 @@ export class AztecAddress {
     ]);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('AztecAddress', AztecAddress);

package/src/block/attestation_info.ts

@@ -1,9 +1,9 @@
-import { recoverAddress } from '@aztec/foundation/crypto';
+import { recoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
+import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
-import type { L2Block } from './l2_block.js';
 import type { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -29,14 +29,14 @@ export type AttestationInfo =
     };
 
 /**
- * Extracts attestation information from a published L2 block.
+ * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
  */
-export function getAttestationInfoFromPublishedL2Block(block: {
+export function getAttestationInfoFromPublishedCheckpoint(block: {
   attestations: CommitteeAttestation[];
-  block: L2Block;
+  checkpoint: Checkpoint;
 }): AttestationInfo[] {
-  const payload = ConsensusPayload.fromBlock(block.block);
+  const payload = ConsensusPayload.fromCheckpoint(block.checkpoint);
   return getAttestationInfoFromPayload(payload, block.attestations);
 }
 
@@ -44,7 +44,10 @@ export function getAttestationInfoFromPayload(
   payload: ConsensusPayload,
   attestations: CommitteeAttestation[],
 ): AttestationInfo[] {
-  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
 
   return attestations.map(attestation => {
     // If signature is empty, check if we have an address directly

package/src/block/block_data.ts

@@ -0,0 +1,25 @@
+import { CheckpointNumberSchema, IndexWithinCheckpointSchema } from '@aztec/foundation/branded-types';
+import type { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+
+import { z } from 'zod';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { BlockHash } from './block_hash.js';
+
+/** L2Block metadata. Equivalent to L2Block but without block body containing tx data. */
+export type BlockData = {
+  header: BlockHeader;
+  archive: AppendOnlyTreeSnapshot;
+  blockHash: BlockHash;
+  checkpointNumber: CheckpointNumber;
+  indexWithinCheckpoint: IndexWithinCheckpoint;
+};
+
+export const BlockDataSchema = z.object({
+  header: BlockHeader.schema,
+  archive: AppendOnlyTreeSnapshot.schema,
+  blockHash: BlockHash.schema,
+  checkpointNumber: CheckpointNumberSchema,
+  indexWithinCheckpoint: IndexWithinCheckpointSchema,
+});

package/src/block/block_hash.ts

@@ -1,44 +1,52 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
+import { GENESIS_BLOCK_HEADER_HASH as GENESIS_BLOCK_HEADER_HASH_FR } from '@aztec/constants';
+import { BaseFr, Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import type { BufferReader } from '@aztec/foundation/serialize';
 
-import { schemas } from '../schemas/schemas.js';
+import { inspect } from 'util';
+
+import { hexSchemaFor } from '../schemas/schemas.js';
 
 /** Hash of an L2 block. */
-export class L2BlockHash extends Buffer32 {
-  constructor(
-    /** The buffer containing the hash. */
-    hash: Buffer,
-  ) {
+export class BlockHash extends BaseFr {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'BlockHash';
+
+  static ZERO = new BlockHash(Fr.ZERO);
+
+  constructor(hash: Fr) {
     super(hash);
   }
 
-  static override random() {
-    return new L2BlockHash(Fr.random().toBuffer());
+  [inspect.custom]() {
+    return `BlockHash<${this.toString()}>`;
   }
 
-  static override fromNumber(num: number): L2BlockHash {
-    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  toFr(): Fr {
+    return new Fr(this.toBigInt());
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+  /** Type guard that checks if a value is a BlockHash instance. */
+  static isBlockHash(value: unknown): value is BlockHash {
+    return value instanceof BlockHash;
   }
 
-  static override fromString(str: string): Buffer32 {
-    return new L2BlockHash(super.fromString(str).toBuffer());
+  static random() {
+    return new BlockHash(Fr.random());
   }
 
-  static get schema() {
-    return schemas.BufferHex.transform(value => new L2BlockHash(value));
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHash {
+    return new BlockHash(Fr.fromBuffer(buffer));
   }
 
-  static zero() {
-    return new L2BlockHash(Buffer32.ZERO.toBuffer());
+  static fromString(str: string): BlockHash {
+    return new BlockHash(Fr.fromString(str));
   }
 
-  static override fromField(hash: Fr) {
-    return new L2BlockHash(hash.toBuffer());
+  static get schema() {
+    return hexSchemaFor(BlockHash) as ZodFor<BlockHash>;
   }
 }
+
+/** The block header hash for the genesis block (block 0). */
+export const GENESIS_BLOCK_HEADER_HASH: BlockHash = new BlockHash(GENESIS_BLOCK_HEADER_HASH_FR);

package/src/block/block_parameter.ts

@@ -0,0 +1,10 @@
+import { BlockNumberSchema } from '@aztec/foundation/branded-types';
+
+import { z } from 'zod';
+
+import { BlockHash } from './block_hash.js';
+
+export const BlockParameterSchema = z.union([BlockHash.schema, BlockNumberSchema, z.literal('latest')]);
+
+/** Block parameter - either a specific BlockNumber, block hash (BlockHash), or 'latest' */
+export type BlockParameter = z.infer<typeof BlockParameterSchema>;

package/src/block/body.ts

@@ -5,6 +5,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { MAX_TX_EFFECTS_PER_BODY } from '../deserialization/index.js';
 import type { ZodFor } from '../schemas/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
 
@@ -40,7 +41,7 @@ export class Body {
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
 
-    return new this(reader.readVector(TxEffect));
+    return new this(reader.readVector(TxEffect, MAX_TX_EFFECTS_PER_BODY));
   }
 
   /**

package/src/block/checkpointed_l2_block.ts

@@ -0,0 +1,70 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/**
+ * Encapsulates an L2 Block along with the checkpoint data associated with it.
+ */
+export class CheckpointedL2Block {
+  constructor(
+    public checkpointNumber: CheckpointNumber,
+    public block: L2Block,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+  static get schema() {
+    return z
+      .object({
+        checkpointNumber: CheckpointNumberSchema,
+        block: L2Block.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => CheckpointedL2Block.fromFields(obj));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpointNumber = reader.readNumber();
+    const block = reader.readObject(L2Block);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
+    return new CheckpointedL2Block(
+      CheckpointNumber(checkpointNumber),
+      block,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  static fromFields(fields: FieldsOf<CheckpointedL2Block>) {
+    return new CheckpointedL2Block(
+      CheckpointNumber(fields.checkpointNumber),
+      fields.block,
+      fields.l1,
+      fields.attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpointNumber,
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/block/in_block.ts

@@ -1,36 +1,49 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+
 import { type ZodTypeAny, z } from 'zod';
 
-import { schemas } from '../schemas/index.js';
-import { L2BlockHash } from './block_hash.js';
+import { BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
+export type InBlock = {
+  l2BlockNumber: BlockNumber;
+  l2BlockHash: BlockHash;
+};
+
 // Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
-export type InBlock<T> = {
-  l2BlockNumber: number;
-  l2BlockHash: L2BlockHash;
+export type DataInBlock<T> = {
   data: T;
-};
+} & InBlock;
+
+export function randomInBlock(): InBlock {
+  return {
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000) + 1),
+    l2BlockHash: BlockHash.random(),
+  };
+}
 
-export function randomInBlock<T>(data: T): InBlock<T> {
+export function randomDataInBlock<T>(data: T): DataInBlock<T> {
   return {
+    ...randomInBlock(),
     data,
-    l2BlockNumber: Math.floor(Math.random() * 1000),
-    l2BlockHash: L2BlockHash.random(),
   };
 }
 
-export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T>> {
+export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: L2BlockHash.fromField(await block.hash()),
+    l2BlockHash: await block.hash(),
   };
 }
 
-export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+export function inBlockSchema() {
   return z.object({
-    data: schema,
-    l2BlockNumber: schemas.Integer,
-    l2BlockHash: L2BlockHash.schema,
+    l2BlockNumber: BlockNumberSchema,
+    l2BlockHash: BlockHash.schema,
   });
 }
+
+export function dataInBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
+  return inBlockSchema().extend({ data: schema });
+}

package/src/block/index.ts

@@ -1,13 +1,12 @@
+export * from './block_data.js';
 export * from './l2_block.js';
-export * from './l2_block_new.js';
-export * from './l2_block_header.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
-export * from './l2_block_number.js';
+export * from './block_parameter.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
-export * from './published_l2_block.js';
+export * from './checkpointed_l2_block.js';
 export * from './proposal/index.js';
 export * from './validate_block_result.js';
 export * from './l2_block_info.js';