@aztec/stdlib 2.0.3 → 2.1.0-rc.10

package/src/block/proposal/attestations_and_signers.ts

@@ -0,0 +1,121 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import { hexToBuffer } from '@aztec/foundation/string';
+
+import { encodeAbiParameters, parseAbiParameters } from '@spalladino/viem';
+import { z } from 'zod';
+
+import type { Signable, SignatureDomainSeparator } from '../../p2p/signature_utils.js';
+import { CommitteeAttestation } from './committee_attestation.js';
+
+export class CommitteeAttestationsAndSigners implements Signable {
+  constructor(public attestations: CommitteeAttestation[]) {}
+
+  static get schema() {
+    return z
+      .object({
+        attestations: CommitteeAttestation.schema.array(),
+      })
+      .transform(obj => new CommitteeAttestationsAndSigners(obj.attestations));
+  }
+
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters('uint8,(bytes,bytes),address[]');
+    const packed = this.getPackedAttestations();
+
+    const encodedData = encodeAbiParameters(abi, [
+      domainSeparator,
+      [packed.signatureIndices, packed.signaturesOrAddresses],
+      this.getSigners().map(s => s.toString()),
+    ]);
+
+    return hexToBuffer(encodedData);
+  }
+
+  static empty(): CommitteeAttestationsAndSigners {
+    return new CommitteeAttestationsAndSigners([]);
+  }
+
+  toString() {
+    return `CommitteeAttestationsAndSigners(${this.attestations.map(a => a.toString()).join(',')})`;
+  }
+
+  getSigners() {
+    return this.attestations.filter(a => !a.signature.isEmpty()).map(a => a.address);
+  }
+
+  getSignedAttestations() {
+    return this.attestations.filter(a => !a.signature.isEmpty());
+  }
+
+  /**
+   * Packs an array of committee attestations into the format expected by the Solidity contract
+   *
+   * @param attestations - Array of committee attestations with addresses and signatures
+   * @returns Packed attestations with bitmap and tightly packed signature/address data
+   */
+  getPackedAttestations(): ViemCommitteeAttestations {
+    const length = this.attestations.length;
+    const attestations = this.attestations.map(a => a.toViem());
+
+    // Calculate bitmap size (1 bit per attestation, rounded up to nearest byte)
+    const bitmapSize = Math.ceil(length / 8);
+    const signatureIndices = new Uint8Array(bitmapSize);
+
+    // Calculate total data size needed
+    let totalDataSize = 0;
+    for (let i = 0; i < length; i++) {
+      const signature = attestations[i].signature;
+      // Check if signature is empty (v = 0)
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        totalDataSize += 65; // v (1) + r (32) + s (32)
+      } else {
+        totalDataSize += 20; // address only
+      }
+    }
+
+    const signaturesOrAddresses = new Uint8Array(totalDataSize);
+    let dataIndex = 0;
+
+    // Pack the data
+    for (let i = 0; i < length; i++) {
+      const attestation = attestations[i];
+      const signature = attestation.signature;
+
+      // Check if signature is empty
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        // Set bit in bitmap (bit 7-0 in each byte, left to right)
+        const byteIndex = Math.floor(i / 8);
+        const bitIndex = 7 - (i % 8);
+        signatureIndices[byteIndex] |= 1 << bitIndex;
+
+        // Pack signature: v + r + s
+        signaturesOrAddresses[dataIndex] = signature.v;
+        dataIndex++;
+
+        // Pack r (32 bytes)
+        const rBytes = Buffer.from(signature.r.slice(2), 'hex');
+        signaturesOrAddresses.set(rBytes, dataIndex);
+        dataIndex += 32;
+
+        // Pack s (32 bytes)
+        const sBytes = Buffer.from(signature.s.slice(2), 'hex');
+        signaturesOrAddresses.set(sBytes, dataIndex);
+        dataIndex += 32;
+      } else {
+        // Pack address only (20 bytes)
+        const addrBytes = Buffer.from(attestation.addr.slice(2), 'hex');
+        signaturesOrAddresses.set(addrBytes, dataIndex);
+        dataIndex += 20;
+      }
+    }
+
+    return {
+      signatureIndices: `0x${Buffer.from(signatureIndices).toString('hex')}`,
+      signaturesOrAddresses: `0x${Buffer.from(signaturesOrAddresses).toString('hex')}`,
+    };
+  }
+}

package/src/block/proposal/committee_attestation.ts

@@ -111,6 +111,10 @@ export class CommitteeAttestation {
     return this.address.equals(other.address) && this.signature.equals(other.signature);
   }
 
+  toString(): string {
+    return `CommitteeAttestation(${this.address.toString()}, ${this.signature.toString()})`;
+  }
+
   toViem(): ViemCommitteeAttestation {
     return {
       addr: this.address.toString(),

package/src/block/proposal/index.ts

@@ -1 +1,2 @@
 export * from './committee_attestation.js';
+export * from './attestations_and_signers.js';

package/src/block/published_l2_block.ts

@@ -83,11 +83,17 @@ export class PublishedL2Block {
   }
 }
 
+/**
+ * Extracts block attestations from a published L2 block.
+ * Returns undefined for attestations with empty signatures, preserving array indices.
+ */
 export function getAttestationsFromPublishedL2Block(
   block: Pick<PublishedL2Block, 'attestations' | 'block'>,
-): BlockAttestation[] {
+): (BlockAttestation | undefined)[] {
   const payload = ConsensusPayload.fromBlock(block.block);
-  return block.attestations
-    .filter(attestation => !attestation.signature.isEmpty())
-    .map(attestation => new BlockAttestation(block.block.number, payload, attestation.signature));
+  return block.attestations.map(attestation =>
+    attestation.signature.isEmpty()
+      ? undefined
+      : new BlockAttestation(block.block.number, payload, attestation.signature),
+  );
 }

package/src/epoch-helpers/index.ts

@@ -118,3 +118,11 @@ export function getProofSubmissionDeadlineTimestamp(
   const [deadlineSlot] = getSlotRangeForEpoch(deadlineEpoch, constants);
   return getTimestampForSlot(deadlineSlot, constants);
 }
+
+/** Returns the timestamp to start building a block for a given L2 slot. Computed as the start timestamp of the slot minus one L1 slot duration. */
+export function getSlotStartBuildTimestamp(
+  slotNumber: number | bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
+): number {
+  return Number(constants.l1GenesisTime) + Number(slotNumber) * constants.slotDuration - constants.ethereumSlotDuration;
+}

package/src/file-store/factory.ts

@@ -4,9 +4,11 @@ import { GoogleCloudFileStore } from './gcs.js';
 import { HttpFileStore } from './http.js';
 import type { FileStore, ReadOnlyFileStore } from './interface.js';
 import { LocalFileStore } from './local.js';
+import { S3FileStore } from './s3.js';
 
 const supportedExamples = [
   `gs://bucket-name/path/to/store`,
+  `s3://bucket-name/path/to/store`,
   `file:///absolute/local/path/to/store`,
   `https://host/path`,
 ];
@@ -39,6 +41,19 @@ export async function createFileStore(
     } catch {
       throw new Error(`Invalid google cloud store definition: '${config}'.`);
     }
+  } else if (config.startsWith('s3://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      const endpoint = url.searchParams.get('endpoint');
+      const publicBaseUrl = url.searchParams.get('publicBaseUrl') ?? undefined;
+      logger.info(`Creating S3 file store at ${bucket} ${path}`);
+      const store = new S3FileStore(bucket, path, { endpoint: endpoint ?? undefined, publicBaseUrl });
+      return store;
+    } catch {
+      throw new Error(`Invalid S3 store definition: '${config}'.`);
+    }
   } else {
     throw new Error(`Unknown file store config: '${config}'. Supported values are ${supportedExamples.join(', ')}.`);
   }

package/src/file-store/interface.ts

@@ -12,8 +12,14 @@ export type FileStoreSaveOptions = { public?: boolean; metadata?: Record<string,
 
 /** Simple file store. */
 export interface FileStore extends ReadOnlyFileStore {
-  /** Saves contents to the given path. Returns an URI that can be used later to `read` the file. */
+  /**
+   * Saves contents to the given path. Returns an URI that can be used later to `read` the file.
+   * Default: `compress` is false unless explicitly set.
+   */
   save(path: string, data: Buffer, opts?: FileStoreSaveOptions): Promise<string>;
-  /** Uploads contents from a local file. Returns an URI that can be used later to `read` the file. */
+  /**
+   * Uploads contents from a local file. Returns an URI that can be used later to `read` the file.
+   * Default: `compress` is true unless explicitly set to false.
+   */
   upload(destPath: string, srcPath: string, opts?: FileStoreSaveOptions): Promise<string>;
 }

package/src/file-store/s3.ts

@@ -0,0 +1,254 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import {
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir, mkdtemp, stat, unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, dirname, join } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+import { createGzip } from 'zlib';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+function normalizeBasePath(path: string): string {
+  return path?.replace(/^\/+|\/+$/g, '') ?? '';
+}
+
+export class S3FileStore implements FileStore {
+  private readonly s3: S3Client;
+  private readonly region: string;
+  private readonly endpoint?: string;
+  private readonly publicBaseUrl?: string;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    opts: { endpoint?: string; publicBaseUrl?: string },
+    private readonly log: Logger = createLogger('stdlib:s3-file-store'),
+  ) {
+    this.endpoint = opts.endpoint;
+    this.region = this.endpoint ? 'auto' : (process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1');
+    this.publicBaseUrl = opts.publicBaseUrl;
+
+    const clientOptions: any = {};
+    if (this.endpoint) {
+      clientOptions.region = 'auto';
+      clientOptions.endpoint = this.endpoint;
+      clientOptions.forcePathStyle = true;
+    } else {
+      clientOptions.region = this.region;
+    }
+    this.s3 = new S3Client(clientOptions);
+  }
+
+  public async save(path: string, data: Buffer, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(path);
+    const shouldCompress = !!opts.compress;
+
+    const body = shouldCompress ? (await import('zlib')).gzipSync(data) : data;
+    const contentLength = body.length;
+    const contentType = this.detectContentType(key, shouldCompress);
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+      ContentLength: contentLength,
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async upload(destPath: string, srcPath: string, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(destPath);
+    const shouldCompress = opts.compress !== false; // default true like GCS impl
+
+    await mkdir(dirname(srcPath), { recursive: true }).catch(() => undefined);
+    let contentLength: number | undefined;
+    let bodyPath = srcPath;
+
+    // We don't set Content-Encoding and we avoid SigV4 streaming (aws-chunked).
+    // With AWS SigV4 streaming uploads (Content-Encoding: aws-chunked[,gzip]), servers require
+    // x-amz-decoded-content-length (the size of the decoded payload) and an exact Content-Length
+    // that includes chunk metadata. For on-the-fly compression, providing
+    // those values without buffering or a pre-pass is impractical. Instead, we pre-gzip to a temp file
+    // to know ContentLength up-front and upload the gzipped bytes as-is, omitting Content-Encoding.
+    // Reference: AWS SigV4 streaming (chunked upload) requirements —
+    // https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html
+    if (shouldCompress) {
+      // Pre-gzip to a temp file so we know the exact length for R2/S3 headers
+      const tmpDir = await mkdtemp(join(tmpdir(), 's3-upload-'));
+      const gzPath = join(tmpDir, `${basename(srcPath)}.gz`);
+      const source = createReadStream(srcPath);
+      const gz = createGzip();
+      const out = createWriteStream(gzPath);
+      try {
+        await finished(source.pipe(gz).pipe(out));
+        const st = await stat(gzPath);
+        contentLength = st.size;
+        bodyPath = gzPath;
+      } catch (err) {
+        // Ensure temp file is removed on failure
+        await unlink(gzPath).catch(() => undefined);
+        throw err;
+      }
+    } else {
+      const st = await stat(srcPath);
+      contentLength = st.size;
+      bodyPath = srcPath;
+    }
+
+    const bodyStream = createReadStream(bodyPath);
+    const contentType = this.detectContentType(key, shouldCompress);
+    try {
+      const put = new PutObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+        Body: bodyStream as any,
+        ContentType: contentType,
+        CacheControl: opts.metadata?.['Cache-control'],
+        Metadata: this.extractUserMetadata(opts.metadata),
+        // Explicitly set ContentLength so R2 can compute x-amz-decoded-content-length correctly
+        ContentLength: contentLength,
+      } as any);
+      await this.s3.send(put);
+    } finally {
+      if (shouldCompress && bodyPath !== srcPath) {
+        await unlink(bodyPath).catch(() => undefined);
+      }
+    }
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const stream = out.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    await mkdir(dirname(destPath), { recursive: true });
+    const write = createWriteStream(destPath);
+    await finished((out.Body as Readable).pipe(write));
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    try {
+      const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+      await this.s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err: any) {
+      const code = err?.$metadata?.httpStatusCode ?? err?.name ?? err?.Code;
+      if (code === 404 || code === 'NotFound' || code === 'NoSuchKey') {
+        return false;
+      }
+      this.log.warn(`Error checking existence for ${pathOrUrlStr}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+  }
+
+  private extractUserMetadata(meta?: Record<string, string>): Record<string, string> | undefined {
+    if (!meta) {
+      return undefined;
+    }
+    const { ['Cache-control']: _ignored, ...rest } = meta;
+    return Object.keys(rest).length ? rest : undefined;
+  }
+
+  private detectContentType(key: string, isCompressed: boolean | undefined): string | undefined {
+    // Basic content type inference
+    const lower = key.toLowerCase();
+    if (lower.endsWith('.json') || lower.endsWith('.json.gz')) {
+      return 'application/json';
+    }
+    if (lower.endsWith('.txt') || lower.endsWith('.log') || lower.endsWith('.csv') || lower.endsWith('.md')) {
+      return 'text/plain; charset=utf-8';
+    }
+    if (lower.endsWith('.db') || lower.endsWith('.sqlite') || lower.endsWith('.bin')) {
+      return 'application/octet-stream';
+    }
+    if (lower.endsWith('.wasm') || lower.endsWith('.wasm.gz')) {
+      return 'application/wasm';
+    }
+    // If compressed, prefer octet-stream unless known
+    if (isCompressed) {
+      return 'application/octet-stream';
+    }
+    return undefined;
+  }
+
+  private buildReturnedUrl(key: string, makePublic: boolean): string {
+    if (!makePublic) {
+      return `s3://${this.bucketName}/${key}`;
+    }
+
+    if (this.publicBaseUrl) {
+      const base = this.publicBaseUrl.replace(/\/$/, '');
+      // key already includes basePath via getFullPath, so do not prefix basePath again
+      const full = key.replace(/^\/+/, '');
+      return `${base}/${full}`;
+    }
+
+    // Try to synthesize a URL from endpoint if available (works for public R2 buckets)
+    if (this.endpoint) {
+      try {
+        const url = new URL(this.endpoint);
+        return `https://${this.bucketName}.${url.host}/${key}`;
+      } catch {
+        // fallthrough
+      }
+    }
+
+    // Fallback to AWS style URL if region looks valid
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  private getBucketAndKey(pathOrUrlStr: string): { bucket: string; key: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      if (url.protocol === 's3:') {
+        return { bucket: url.host, key: url.pathname.replace(/^\/+/, '') };
+      }
+      // For https URLs, try to infer virtual-hosted or path-style
+      if (url.protocol === 'https:' || url.protocol === 'http:') {
+        // If the URL matches the configured publicBaseUrl host, map back to our bucket and key
+        if (this.publicBaseUrl && url.host === new URL(this.publicBaseUrl).host) {
+          return { bucket: this.bucketName, key: url.pathname.replace(/^\/+/, '') };
+        }
+        const hostParts = url.host.split('.');
+        if (hostParts.length > 3 && (hostParts[1] === 's3' || hostParts[hostParts.length - 2] === 'r2')) {
+          // virtual hosted
+          return { bucket: hostParts[0], key: url.pathname.replace(/^\/+/, '') };
+        } else if (this.endpoint && url.host === new URL(this.endpoint).host) {
+          // path-style at custom endpoint
+          const [bucket, ...rest] = url.pathname.replace(/^\/+/, '').split('/');
+          return { bucket, key: rest.join('/') };
+        }
+      }
+    }
+    // Treat as path
+    return { bucket: this.bucketName, key: this.getFullPath(pathOrUrlStr) };
+  }
+
+  private getFullPath(path: string): string {
+    const base = normalizeBasePath(this.basePath);
+    const rel = path.replace(/^\/+/, '');
+    return base ? join(base, rel) : rel;
+  }
+}

package/src/interfaces/block-builder.ts

@@ -43,6 +43,7 @@ export interface PublicProcessorLimits {
   maxTransactions?: number;
   maxBlockSize?: number;
   maxBlockGas?: Gas;
+  maxBlobFields?: number;
   deadline?: Date;
 }
 

package/src/interfaces/configs.ts

@@ -52,6 +52,8 @@ export interface SequencerConfig {
   skipCollectingAttestations?: boolean;
   /** Do not invalidate the previous block if invalid when we are the proposer (for testing only) */
   skipInvalidateBlockAsProposer?: boolean;
+  /** Inject a fake attestation (for testing only) */
+  injectFakeAttestation?: boolean;
 }
 
 export const SequencerConfigSchema = z.object({
@@ -75,4 +77,5 @@ export const SequencerConfigSchema = z.object({
   skipCollectingAttestations: z.boolean().optional(),
   secondsBeforeInvalidatingBlockAsCommitteeMember: z.number(),
   secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.number(),
+  injectFakeAttestation: z.boolean().optional(),
 }) satisfies ZodFor<SequencerConfig>;

package/src/interfaces/slasher.ts

@@ -24,6 +24,7 @@ export interface SlasherConfig {
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
+  slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
 export const SlasherConfigSchema = z.object({
@@ -44,5 +45,6 @@ export const SlasherConfigSchema = z.object({
   slashMaxPayloadSize: z.number(),
   slashGracePeriodL2Slots: z.number(),
   slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  slashExecuteRoundsLookBack: z.number(),
   slashSelfAllowed: z.boolean().optional(),
 }) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/validator.ts

@@ -1,5 +1,6 @@
 import type { SecretValue } from '@aztec/foundation/config';
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -9,6 +10,8 @@ import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
+import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+
 /**
  * Validator client configuration
  */
@@ -28,11 +31,14 @@ export interface ValidatorClientConfig {
   /** Interval between polling for new attestations from peers */
   attestationPollingIntervalMs: number;
 
-  /** Re-execute transactions before attesting */
+  /** Whether to re-execute transactions in a block proposal before attesting */
   validatorReexecute: boolean;
 
   /** Will re-execute until this many milliseconds are left in the slot */
   validatorReexecuteDeadlineMs: number;
+
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
 }
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
@@ -46,11 +52,11 @@ export const ValidatorClientConfigSchema = z.object({
   attestationPollingIntervalMs: z.number().min(0),
   validatorReexecute: z.boolean(),
   validatorReexecuteDeadlineMs: z.number().min(0),
+  alwaysReexecuteBlockProposals: z.boolean().optional(),
 }) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
 
 export interface Validator {
   start(): Promise<void>;
-  registerBlockProposalHandler(): void;
   updateConfig(config: Partial<ValidatorClientFullConfig>): void;
 
   // Block validation responsibilities
@@ -67,4 +73,8 @@ export interface Validator {
 
   broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
   collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+  signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature>;
 }

package/src/l1-contracts/slash_factory.ts

@@ -4,7 +4,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
 
-import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from 'viem';
+import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from '@spalladino/viem';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import {

package/src/p2p/block_attestation.ts

@@ -81,6 +81,18 @@ export class BlockAttestation extends Gossipable {
     return this.sender;
   }
 
+  /**
+   * Tries to get the sender of the attestation
+   * @returns The sender of the attestation or undefined if it fails during recovery
+   */
+  tryGetSender(): EthAddress | undefined {
+    try {
+      return this.getSender();
+    } catch {
+      return undefined;
+    }
+  }
+
   getPayload(): Buffer {
     return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
   }
@@ -105,4 +117,12 @@ export class BlockAttestation extends Gossipable {
   getSize(): number {
     return 4 /* blockNumber */ + this.payload.getSize() + this.signature.getSize();
   }
+
+  toInspect() {
+    return {
+      blockNumber: this.blockNumber,
+      payload: this.payload.toInspect(),
+      signature: this.signature.toString(),
+    };
+  }
 }

package/src/p2p/consensus_payload.ts

@@ -4,7 +4,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import { encodeAbiParameters, parseAbiParameters } from '@spalladino/viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
@@ -63,6 +63,14 @@ export class ConsensusPayload implements Signable {
     return serializeToBuffer([this.header, this.archive, this.stateReference]);
   }
 
+  public equals(other: ConsensusPayload): boolean {
+    return (
+      this.header.equals(other.header) &&
+      this.archive.equals(other.archive) &&
+      this.stateReference.equals(other.stateReference)
+    );
+  }
+
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
     const payload = new ConsensusPayload(
@@ -102,6 +110,14 @@ export class ConsensusPayload implements Signable {
     return this.size;
   }
 
+  toInspect() {
+    return {
+      header: this.header.toInspect(),
+      archive: this.archive.toString(),
+      stateReference: this.stateReference.toInspect(),
+    };
+  }
+
   toString() {
     return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
   }