@aztec/stdlib 2.0.3 → 2.1.0-rc.10

package/src/p2p/gossipable.ts

@@ -1,33 +1,23 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
 
 export class P2PMessage {
-  constructor(
-    public readonly publishTime: Date,
-    public readonly id: Buffer32,
-    public readonly payload: Buffer,
-  ) {}
+  constructor(public readonly payload: Buffer) {}
 
-  static async fromGossipable(message: Gossipable): Promise<P2PMessage> {
-    return new P2PMessage(new Date(), await message.p2pMessageIdentifier(), message.toBuffer());
+  static fromGossipable(message: Gossipable): P2PMessage {
+    return new P2PMessage(message.toBuffer());
   }
 
   static fromMessageData(messageData: Buffer): P2PMessage {
     const reader = new BufferReader(messageData);
-    const publishTime = reader.readUInt64();
-    const id = Buffer32.fromBuffer(reader);
     const payload = reader.readBuffer();
-    return new P2PMessage(new Date(Number(publishTime)), id, payload);
+    return new P2PMessage(payload);
   }
 
   toMessageData(): Buffer {
-    return serializeToBuffer([
-      bigintToUInt64BE(BigInt(this.publishTime.getTime())),
-      this.id,
-      serializeToBuffer(this.payload.length, this.payload),
-    ]);
+    return serializeToBuffer([serializeToBuffer(this.payload.length, this.payload)]);
   }
 }
 

package/src/p2p/signature_utils.ts

@@ -4,6 +4,7 @@ import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
 export enum SignatureDomainSeparator {
   blockProposal = 0,
   blockAttestation = 1,
+  attestationsAndSigners = 2,
 }
 
 export interface Signable {

package/src/slashing/types.ts

@@ -22,6 +22,29 @@ export enum OffenseType {
   ATTESTED_DESCENDANT_OF_INVALID = 7,
 }
 
+export function getOffenseTypeName(offense: OffenseType) {
+  switch (offense) {
+    case OffenseType.UNKNOWN:
+      return 'unknown';
+    case OffenseType.DATA_WITHHOLDING:
+      return 'data_withholding';
+    case OffenseType.VALID_EPOCH_PRUNED:
+      return 'valid_epoch_pruned';
+    case OffenseType.INACTIVITY:
+      return 'inactivity';
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+      return 'broadcasted_invalid_block_proposal';
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+      return 'proposed_insufficient_attestations';
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return 'proposed_incorrect_attestations';
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+      return 'attested_descendant_of_invalid';
+    default:
+      throw new Error(`Unknown offense type: ${offense}`);
+  }
+}
+
 export const OffenseTypeSchema = z.nativeEnum(OffenseType);
 
 export const OffenseToBigInt: Record<OffenseType, bigint> = {

package/src/snapshots/download.ts

@@ -2,6 +2,12 @@ import { fromEntries, getEntries, maxBy } from '@aztec/foundation/collection';
 import { jsonParseWithSchema } from '@aztec/foundation/json-rpc';
 import type { ReadOnlyFileStore } from '@aztec/stdlib/file-store';
 
+import { createReadStream, createWriteStream } from 'fs';
+import fs from 'fs/promises';
+import pathMod from 'path';
+import { pipeline } from 'stream/promises';
+import { createGunzip, gunzipSync } from 'zlib';
+
 import {
   SnapshotDataKeys,
   type SnapshotDataUrls,
@@ -20,7 +26,8 @@ export async function getSnapshotIndex(
   try {
     if (await store.exists(snapshotIndexPath)) {
       const snapshotIndexData = await store.read(snapshotIndexPath);
-      return jsonParseWithSchema(snapshotIndexData.toString(), SnapshotsIndexSchema);
+      const buf = maybeGunzip(snapshotIndexData);
+      return jsonParseWithSchema(buf.toString('utf-8'), SnapshotsIndexSchema);
     } else {
       return undefined;
     }
@@ -50,10 +57,67 @@ export function makeSnapshotPaths(baseDir: string): SnapshotDataUrls {
   return fromEntries(SnapshotDataKeys.map(key => [key, `${baseDir}/${key}.db`]));
 }
 
+function isGzipMagic(data: Buffer): boolean {
+  return data.length >= 2 && data[0] === 0x1f && data[1] === 0x8b;
+}
+
+function maybeGunzip(data: Buffer): Buffer {
+  const magicNumberIndicatesGzip = isGzipMagic(data);
+
+  if (magicNumberIndicatesGzip) {
+    try {
+      const out = gunzipSync(data);
+      return out;
+    } catch (err) {
+      throw new Error(`Decompression of gzipped data failed: ${(err as Error).message}`);
+    }
+  }
+  return data;
+}
+
+async function detectGzip(localFilePathToPeek: string): Promise<boolean> {
+  // Peek the actual bytes we downloaded.
+  try {
+    const fd = await fs.open(localFilePathToPeek, 'r');
+    try {
+      const header = Buffer.alloc(2);
+      const { bytesRead } = await fd.read(header, 0, 2, 0);
+      return bytesRead >= 2 && isGzipMagic(header);
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return false;
+  }
+}
+
 export async function downloadSnapshot(
   snapshot: Pick<SnapshotMetadata, 'dataUrls'>,
   localPaths: Record<SnapshotDataKeys, string>,
   store: ReadOnlyFileStore,
 ): Promise<void> {
-  await Promise.all(getEntries(localPaths).map(([key, path]) => store.download(snapshot.dataUrls[key], path)));
+  await Promise.all(
+    getEntries(localPaths).map(async ([key, path]) => {
+      await fs.mkdir(pathMod.dirname(path), { recursive: true });
+
+      const tmpPath = `${path}.download`;
+      try {
+        const url = snapshot.dataUrls[key];
+        await store.download(url, tmpPath);
+
+        const isGzip = await detectGzip(tmpPath);
+
+        const read = createReadStream(tmpPath);
+        const write = createWriteStream(path);
+        if (isGzip) {
+          const gunzip = createGunzip();
+          await pipeline(read, gunzip, write);
+        } else {
+          await pipeline(read, write);
+        }
+      } finally {
+        await fs.unlink(tmpPath).catch(() => undefined);
+      }
+    }),
+  );
 }

package/src/snapshots/upload.ts

@@ -48,6 +48,7 @@ export async function uploadSnapshotToIndex(
 
   await store.save(getSnapshotIndexPath(metadata), Buffer.from(jsonStringify(snapshotsIndex, true)), {
     public: true, // Make the index publicly accessible
+    compress: false, // Ensure index.json is not gzipped
     metadata: { ['Cache-control']: 'no-store' }, // Do not cache object versions
   });
   return newSnapshotMetadata;

package/src/tests/mocks.ts

@@ -8,6 +8,7 @@ import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { CommitteeAttestation, L1PublishedData } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
+import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
@@ -273,6 +274,17 @@ const makeAndSignConsensusPayload = (
   return { blockNumber: header.globalVariables.blockNumber, payload, signature };
 };
 
+export const makeAndSignCommitteeAttestationsAndSigners = (
+  attestationsAndSigners: CommitteeAttestationsAndSigners,
+  signer: Secp256k1Signer = Secp256k1Signer.random(),
+) => {
+  const hash = getHashedSignaturePayloadEthSignedMessage(
+    attestationsAndSigners,
+    SignatureDomainSeparator.attestationsAndSigners,
+  );
+  return signer.sign(hash);
+};
+
 export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
   const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
     SignatureDomainSeparator.blockProposal,

package/src/tx/proposed_block_header.ts

@@ -84,6 +84,19 @@ export class ProposedBlockHeader {
     );
   }
 
+  equals(other: ProposedBlockHeader): boolean {
+    return (
+      this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
+      this.contentCommitment.equals(other.contentCommitment) &&
+      this.slotNumber.equals(other.slotNumber) &&
+      this.timestamp === other.timestamp &&
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.totalManaUsed.equals(other.totalManaUsed)
+    );
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer([

package/src/tx/state_reference.ts

@@ -137,6 +137,6 @@ export class StateReference {
   }
 
   public equals(other: this): boolean {
-    return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
   }
 }

package/src/tx/tx.ts

@@ -207,16 +207,6 @@ export class Tx extends Gossipable {
     return this.txHash;
   }
 
-  /**
-   * Allows setting the hash of the Tx.
-   * Use this when you want to skip computing it from the original data.
-   * Don't set a Tx hash received from an untrusted source.
-   * @param hash - The hash to set.
-   */
-  setTxHash(_hash: TxHash) {
-    return this;
-  }
-
   getCalldataMap(): Map<string, Fr[]> {
     if (!this.calldataMap) {
       const calldataMap = new Map();