@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/p2p/consensus_payload.ts

@@ -0,0 +1,91 @@
+import { Fr } from '@aztec/foundation/fields';
+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 { z } from 'zod';
+
+import { BlockHeader } from '../tx/block_header.js';
+import { TxHash } from '../tx/tx_hash.js';
+import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
+
+export class ConsensusPayload implements Signable {
+  private size: number | undefined;
+
+  constructor(
+    /** The block header the attestation is made over */
+    public readonly header: BlockHeader,
+    // TODO(https://github.com/AztecProtocol/aztec-packages/pull/7727#discussion_r1713670830): temporary
+    public readonly archive: Fr,
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        header: BlockHeader.schema,
+        archive: Fr.schema,
+        txHashes: z.array(TxHash.schema),
+      })
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+  }
+
+  static getFields(fields: FieldsOf<ConsensusPayload>) {
+    return [fields.header, fields.archive, fields.txHashes] as const;
+  }
+
+  async getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer> {
+    const abi = parseAbiParameters('uint8, (bytes32, bytes32, (uint256), bytes, bytes32[])');
+    const txArray = this.txHashes.map(tx => tx.toString());
+    const encodedData = encodeAbiParameters(abi, [
+      domainSeparator,
+      [
+        this.archive.toString(),
+        (await this.header.hash()).toString(),
+        [0n] /* @todo See #9963 */,
+        this.header.toString(),
+        txArray,
+      ],
+    ] as const);
+
+    return hexToBuffer(encodedData);
+  }
+
+  toBuffer(): Buffer {
+    const buffer = serializeToBuffer([this.header, this.archive, this.txHashes.length, this.txHashes]);
+    this.size = buffer.length;
+    return buffer;
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
+    const reader = BufferReader.asReader(buf);
+    return new ConsensusPayload(
+      reader.readObject(BlockHeader),
+      reader.readObject(Fr),
+      reader.readArray(reader.readNumber(), TxHash),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
+    return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+  }
+
+  static empty(): ConsensusPayload {
+    return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+  }
+
+  /**
+   * Get the size of the consensus payload in bytes.
+   * @returns The size of the consensus payload.
+   */
+  getSize(): number {
+    // We cache size to avoid recalculating it
+    if (this.size) {
+      return this.size;
+    }
+    this.size = this.toBuffer().length;
+    return this.size;
+  }
+}

package/src/p2p/gossipable.ts

@@ -0,0 +1,33 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+
+/**
+ * Gossipable
+ *
+ * Any class which extends gossipable will be able to be Gossiped over the p2p network
+ */
+export abstract class Gossipable {
+  /** p2p Topic
+   *
+   * - The p2p topic identifier, this determines how the message is handled
+   */
+  static p2pTopic: string;
+
+  /** p2p Message Identifier
+   *
+   *  - A digest of the message information, this key is used for deduplication
+   */
+  abstract p2pMessageIdentifier(): Promise<Buffer32>;
+
+  /** To Buffer
+   *
+   * - Serialization method
+   */
+  abstract toBuffer(): Buffer;
+
+  /**
+   * Get the size of the gossipable object.
+   *
+   * This is used for metrics recording.
+   */
+  abstract getSize(): number;
+}

package/src/p2p/index.ts

@@ -0,0 +1,10 @@
+export * from './block_attestation.js';
+export * from './block_proposal.js';
+export * from './consensus_payload.js';
+export * from './gossipable.js';
+export * from './interface.js';
+export * from './signature_utils.js';
+export * from './topic_type.js';
+export * from './client_type.js';
+export * from './message_validator.js';
+export * from './peer_error.js';

package/src/p2p/interface.ts

@@ -0,0 +1,28 @@
+import { Tx } from '../tx/tx.js';
+import { BlockAttestation } from './block_attestation.js';
+import { BlockProposal } from './block_proposal.js';
+import type { Gossipable } from './gossipable.js';
+import { TopicType } from './topic_type.js';
+
+export interface RawGossipMessage {
+  topic: string;
+  data: Uint8Array;
+}
+
+// Force casts as we know that each field here extends Gossipable, and we just want types from Gossipable
+export const TopicTypeMap: Record<string, typeof Gossipable> = {
+  [TopicType.tx]: Tx as unknown as typeof Gossipable,
+  [TopicType.block_proposal]: BlockProposal as unknown as typeof Gossipable,
+  [TopicType.block_attestation]: BlockAttestation as unknown as typeof Gossipable,
+};
+
+/**
+ * Map from topic to deserialiser
+ *
+ * Used in msgIdFn libp2p to get the p2pMessageIdentifier from a message
+ */
+export const TopicToDeserializer = {
+  [Tx.p2pTopic]: Tx.fromBuffer,
+  [BlockProposal.p2pTopic]: BlockProposal.fromBuffer,
+  [BlockAttestation.p2pTopic]: BlockAttestation.fromBuffer,
+};

package/src/p2p/message_validator.ts

@@ -0,0 +1,10 @@
+import type { PeerErrorSeverity } from './peer_error.js';
+
+/**
+ * P2PValidator
+ *
+ * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ */
+export interface P2PValidator<T> {
+  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+}

package/src/p2p/peer_error.ts

@@ -0,0 +1,17 @@
+export enum PeerErrorSeverity {
+  /**
+   * Not malicious action, but it must not be tolerated
+   * ~2 occurrences will get the peer banned
+   */
+  LowToleranceError = 'LowToleranceError',
+  /**
+   * Negative action that can be tolerated only sometimes
+   * ~10 occurrences will get the peer banned
+   */
+  MidToleranceError = 'MidToleranceError',
+  /**
+   * Some error that can be tolerated multiple times
+   * ~50 occurrences will get the peer banned
+   */
+  HighToleranceError = 'HighToleranceError',
+}

package/src/p2p/signature_utils.ts

@@ -0,0 +1,36 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
+
+export enum SignatureDomainSeparator {
+  blockProposal = 0,
+  blockAttestation = 1,
+}
+
+export interface Signable {
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer>;
+}
+
+/**
+ * Get the hashed payload for the signature of the `Signable`
+ * @param s - The `Signable` to sign
+ * @returns The hashed payload for the signature of the `Signable`
+ */
+export async function getHashedSignaturePayload(
+  s: Signable,
+  domainSeparator: SignatureDomainSeparator,
+): Promise<Buffer32> {
+  return Buffer32.fromBuffer(keccak256(await s.getPayloadToSign(domainSeparator)));
+}
+
+/**
+ * Get the hashed payload for the signature of the `Signable` as an Ethereum signed message EIP-712
+ * @param s - the `Signable` to sign
+ * @returns The hashed payload for the signature of the `Signable` as an Ethereum signed message
+ */
+export async function getHashedSignaturePayloadEthSignedMessage(
+  s: Signable,
+  domainSeparator: SignatureDomainSeparator,
+): Promise<Buffer32> {
+  const payload = await getHashedSignaturePayload(s, domainSeparator);
+  return makeEthSignDigest(payload);
+}

package/src/p2p/topic_type.ts

@@ -0,0 +1,45 @@
+import { P2PClientType } from './client_type.js';
+
+/** Create Topic String
+ *
+ * The topic channel identifier
+ * @param topicType
+ * @returns
+ */
+export function createTopicString(topicType: TopicType) {
+  return '/aztec/' + topicType + '/0.1.0';
+}
+
+/**
+ *
+ */
+export enum TopicType {
+  tx = 'tx',
+  block_proposal = 'block_proposal',
+  block_attestation = 'block_attestation',
+}
+
+export function getTopicTypeForClientType(clientType: P2PClientType) {
+  if (clientType === P2PClientType.Full) {
+    return Object.values(TopicType);
+  }
+  return [TopicType.tx];
+}
+
+/**
+ * Convert the topic string into a set of labels
+ *
+ * In the form:
+ * {
+ *  "/aztec/tx/0.1.0": "tx",
+ *  ...
+ * }
+ */
+export function metricsTopicStrToLabels() {
+  const topicStrToLabel = new Map<string, string>();
+  for (const topic in TopicType) {
+    topicStrToLabel.set(createTopicString(TopicType[topic as keyof typeof TopicType]), topic);
+  }
+
+  return topicStrToLabel;
+}

package/src/parity/base_parity_inputs.ts

@@ -0,0 +1,63 @@
+import { type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+export class BaseParityInputs {
+  constructor(
+    /** Aggregated proof of all the parity circuit iterations. */
+    public readonly msgs: Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>,
+    /** Root of the VK tree */
+    public readonly vkTreeRoot: Fr,
+  ) {}
+
+  public static fromSlice(
+    array: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
+    index: number,
+    vkTreeRoot: Fr,
+  ): BaseParityInputs {
+    const start = index * NUM_MSGS_PER_BASE_PARITY;
+    const end = start + NUM_MSGS_PER_BASE_PARITY;
+    const msgs = array.slice(start, end);
+    return new BaseParityInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
+  }
+
+  /** Serializes the inputs to a buffer. */
+  toBuffer() {
+    return serializeToBuffer(this.msgs, this.vkTreeRoot);
+  }
+
+  /** Serializes the inputs to a hex string. */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BaseParityInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - The hex string to deserialize from.
+   * @returns - The deserialized inputs.
+   */
+  static fromString(str: string) {
+    return BaseParityInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(BaseParityInputs);
+  }
+}

package/src/parity/index.ts

@@ -0,0 +1,4 @@
+export * from './base_parity_inputs.js';
+export * from './parity_public_inputs.js';
+export * from './root_parity_input.js';
+export * from './root_parity_inputs.js';

package/src/parity/parity_public_inputs.ts

@@ -0,0 +1,82 @@
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+export class ParityPublicInputs {
+  constructor(
+    /** Root of the SHA256 tree. */
+    public shaRoot: Fr,
+    /** Root of the converted tree. */
+    public convertedRoot: Fr,
+    /** Root of the VK tree */
+    public vkTreeRoot: Fr,
+  ) {
+    if (shaRoot.toBuffer()[0] != 0) {
+      throw new Error(`shaRoot buffer must be 31 bytes. Got 32 bytes`);
+    }
+  }
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...ParityPublicInputs.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The inputs serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /**
+   * Creates a new ParityPublicInputs instance from the given fields.
+   * @param fields - The fields to create the instance from.
+   * @returns The instance.
+   */
+  static from(fields: FieldsOf<ParityPublicInputs>): ParityPublicInputs {
+    return new ParityPublicInputs(...ParityPublicInputs.getFields(fields));
+  }
+
+  /**
+   * Extracts the fields from the given instance.
+   * @param fields - The instance to get the fields from.
+   * @returns The instance fields.
+   */
+  static getFields(fields: FieldsOf<ParityPublicInputs>) {
+    return [fields.shaRoot, fields.convertedRoot, fields.vkTreeRoot] as const;
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new ParityPublicInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ParityPublicInputs(reader.readObject(Fr), reader.readObject(Fr), Fr.fromBuffer(reader));
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - The hex string to deserialize from.
+   * @returns A new ParityPublicInputs instance.
+   */
+  static fromString(str: string) {
+    return ParityPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ParityPublicInputs);
+  }
+}

package/src/parity/root_parity_input.ts

@@ -0,0 +1,71 @@
+import { VK_TREE_HEIGHT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { ParityPublicInputs } from './parity_public_inputs.js';
+
+export class RootParityInput<PROOF_LENGTH extends number> {
+  constructor(
+    /** The proof of the execution of the parity circuit. */
+    public readonly proof: RecursiveProof<PROOF_LENGTH>,
+    /** The circuit's verification key */
+    public readonly verificationKey: VerificationKeyAsFields,
+    /** The vk path in the vk tree*/
+    public readonly vkPath: Tuple<Fr, typeof VK_TREE_HEIGHT>,
+    /** The public inputs of the parity circuit. */
+    public readonly publicInputs: ParityPublicInputs,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(...RootParityInput.getFields(this));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static from<PROOF_LENGTH extends number>(
+    fields: FieldsOf<RootParityInput<PROOF_LENGTH>>,
+  ): RootParityInput<PROOF_LENGTH> {
+    return new RootParityInput(...RootParityInput.getFields(fields));
+  }
+
+  static getFields<PROOF_LENGTH extends number>(fields: FieldsOf<RootParityInput<PROOF_LENGTH>>) {
+    return [fields.proof, fields.verificationKey, fields.vkPath, fields.publicInputs] as const;
+  }
+
+  static fromBuffer<PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    expectedSize?: PROOF_LENGTH,
+  ): RootParityInput<PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new RootParityInput(
+      RecursiveProof.fromBuffer<PROOF_LENGTH>(reader, expectedSize),
+      reader.readObject(VerificationKeyAsFields),
+      reader.readArray(VK_TREE_HEIGHT, Fr),
+      reader.readObject(ParityPublicInputs),
+    );
+  }
+
+  static fromString<PROOF_LENGTH extends number>(
+    str: string,
+    expectedSize?: PROOF_LENGTH,
+  ): RootParityInput<PROOF_LENGTH> {
+    return RootParityInput.fromBuffer(hexToBuffer(str), expectedSize);
+  }
+
+  /** Returns a hex representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string with expected size. */
+  static schemaFor<N extends number>(expectedSize?: N) {
+    return schemas.Buffer.transform(buf => RootParityInput.fromBuffer(buf, expectedSize));
+  }
+}

package/src/parity/root_parity_inputs.ts

@@ -0,0 +1,66 @@
+import { NUM_BASE_PARITY_PER_ROOT_PARITY, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { RootParityInput } from './root_parity_input.js';
+
+export class RootParityInputs {
+  constructor(
+    /** Public inputs of children and their proofs. */
+    public readonly children: Tuple<
+      RootParityInput<typeof RECURSIVE_PROOF_LENGTH>,
+      typeof NUM_BASE_PARITY_PER_ROOT_PARITY
+    >,
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...this.children);
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new RootParityInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const tuple = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, () =>
+      RootParityInput.fromBuffer(reader, RECURSIVE_PROOF_LENGTH),
+    );
+    return new RootParityInputs(
+      tuple as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
+    );
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new RootParityInputs instance.
+   */
+  static fromString(str: string) {
+    return RootParityInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(RootParityInputs);
+  }
+}

package/src/proofs/client_ivc_proof.ts

@@ -0,0 +1,61 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+const CLIENT_IVC_PROOF_LENGTH = 172052;
+const CLIENT_IVC_VK_LENGTH = 2730;
+
+/**
+ * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
+ * eventually we read all these VKs from the data tree instead of passing them
+ */
+export class ClientIvcProof {
+  constructor(
+    // produced by the sequencer when making the tube proof
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370): Need to precompute private kernel tail VK so we can verify this immediately in the tx pool
+    // which parts of these are needed to quickly verify that we have a correct IVC proof
+    public clientIvcProofBuffer: Buffer,
+    public clientIvcVkBuffer: Buffer,
+  ) {}
+
+  public isEmpty() {
+    return this.clientIvcProofBuffer.length === 0;
+  }
+
+  static empty() {
+    return new ClientIvcProof(Buffer.from(''), Buffer.from(''));
+  }
+
+  static fake(fill = Math.floor(Math.random() * 255)) {
+    return new ClientIvcProof(Buffer.alloc(1, fill), Buffer.alloc(1, fill));
+  }
+
+  static random() {
+    return new ClientIvcProof(
+      Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)),
+      Buffer.from(randomBytes(CLIENT_IVC_VK_LENGTH)),
+    );
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ClientIvcProof);
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
+    const reader = BufferReader.asReader(buffer);
+    return new ClientIvcProof(reader.readBuffer(), reader.readBuffer());
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(
+      this.clientIvcProofBuffer.length,
+      this.clientIvcProofBuffer,
+      this.clientIvcVkBuffer.length,
+      this.clientIvcVkBuffer,
+    );
+  }
+}

package/src/proofs/index.ts

@@ -0,0 +1,4 @@
+export * from './recursive_proof.js';
+export * from './client_ivc_proof.js';
+export * from './proof.js';
+export * from './proving_request_type.js';