@aztec/blob-lib 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/src/blob_utils.ts

@@ -1,9 +1,11 @@
 import { FIELDS_PER_BLOB } from '@aztec/constants';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
+import type { BatchedBlob } from './batched_blob.js';
 import { Blob } from './blob.js';
-import { deserializeEncodedBlobToFields } from './deserialize.js';
-import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
+import { type CheckpointBlobData, decodeCheckpointBlobDataFromBuffer } from './encoding/index.js';
+import { computeBlobsHash, computeEthVersionedBlobHash } from './hash.js';
 
 /**
  * @param blobs - The blobs to emit.
@@ -28,38 +30,27 @@ export function getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}` {
  *
  * @throws If the number of fields does not match what's indicated by the checkpoint prefix.
  */
-export function getBlobsPerL1Block(fields: Fr[]): Blob[] {
+export async function getBlobsPerL1Block(fields: Fr[]): Promise<Blob[]> {
   if (!fields.length) {
     throw new Error('Cannot create blobs from empty fields.');
   }
 
   const numBlobs = Math.ceil(fields.length / FIELDS_PER_BLOB);
-  return Array.from({ length: numBlobs }, (_, i) =>
-    Blob.fromFields(fields.slice(i * FIELDS_PER_BLOB, (i + 1) * FIELDS_PER_BLOB)),
+  return await Promise.all(
+    Array.from({ length: numBlobs }, (_, i) =>
+      Blob.fromFields(fields.slice(i * FIELDS_PER_BLOB, (i + 1) * FIELDS_PER_BLOB)),
+    ),
   );
 }
 
 /**
- * Get the fields from all blobs in the checkpoint. Ignoring the fields beyond the length specified by the
- * checkpoint prefix (the first field).
- *
- * @param blobs - The blobs to read fields from. Should be all the blobs in the L1 block proposing the checkpoint.
- * @param checkEncoding - Whether to check if the entire encoded blob fields are valid. If false, it will still check
- * the checkpoint prefix and throw if there's not enough fields.
- * @returns The fields added throughout the checkpoint.
+ * Get the encoded data from all blobs in the checkpoint.
+ * @param blobs - The blobs to read data from. Should be all the blobs for the L1 block proposing the checkpoint.
+ * @returns The encoded data of the checkpoint.
  */
-export function getBlobFieldsInCheckpoint(blobs: Blob[], checkEncoding = false): Fr[] {
-  return deserializeEncodedBlobToFields(Buffer.concat(blobs.map(b => b.data)), checkEncoding);
-}
-
-export async function computeBlobFieldsHashFromBlobs(blobs: Blob[]): Promise<Fr> {
-  const fields = blobs.map(b => b.toFields()).flat();
-  const numBlobFields = fields[0].toNumber();
-  if (numBlobFields > fields.length) {
-    throw new Error(`The prefix indicates ${numBlobFields} fields. Got ${fields.length}.`);
-  }
-
-  return await computeBlobFieldsHash(fields.slice(0, numBlobFields));
+export function decodeCheckpointBlobDataFromBlobs(blobs: Blob[]): CheckpointBlobData {
+  const buf = Buffer.concat(blobs.map(b => b.data));
+  return decodeCheckpointBlobDataFromBuffer(buf);
 }
 
 export function computeBlobsHashFromBlobs(blobs: Blob[]): Fr {
@@ -69,3 +60,25 @@ export function computeBlobsHashFromBlobs(blobs: Blob[]): Fr {
 export function getBlobCommitmentsFromBlobs(blobs: Blob[]): BLS12Point[] {
   return blobs.map(b => BLS12Point.decompress(b.commitment));
 }
+
+/**
+ * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
+ *
+ * input[:32]     - versioned_hash
+ * input[32:64]   - z
+ * input[64:96]   - y
+ * input[96:144]  - commitment C
+ * input[144:192] - commitment Q (a 'proof' committing to the quotient polynomial q(X))
+ *
+ * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+ */
+export function getEthBlobEvaluationInputs(batchedBlob: BatchedBlob): `0x${string}` {
+  const buf = Buffer.concat([
+    computeEthVersionedBlobHash(batchedBlob.commitment.compress()),
+    batchedBlob.z.toBuffer(),
+    batchedBlob.y.toBuffer(),
+    batchedBlob.commitment.compress(),
+    batchedBlob.q.compress(),
+  ]);
+  return `0x${buf.toString('hex')}`;
+}

package/src/circuit_types/blob_accumulator.ts

@@ -1,5 +1,6 @@
 import { BLS12_FQ_LIMBS, BLS12_FR_LIMBS } from '@aztec/constants';
-import { BLS12Fq, BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fq, BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**
@@ -81,4 +82,15 @@ export class BlobAccumulator {
       BLS12Fr.fromNoirBigNum({ limbs: reader.readFieldArray(BLS12_FR_LIMBS).map(f => f.toString()) }),
     );
   }
+
+  static random() {
+    return new BlobAccumulator(
+      Fr.random(),
+      Fr.random(),
+      BLS12Fr.random(),
+      BLS12Point.random(),
+      Fr.random(),
+      BLS12Fr.random(),
+    );
+  }
 }

package/src/circuit_types/final_blob_accumulator.ts

@@ -1,4 +1,5 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';

package/src/circuit_types/final_blob_batching_challenges.ts

@@ -1,4 +1,5 @@
-import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**

package/src/encoding/block_blob_data.ts

@@ -0,0 +1,114 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+import {
+  type BlockEndMarker,
+  decodeBlockEndMarker,
+  encodeBlockEndMarker,
+  isBlockEndMarker,
+} from './block_end_marker.js';
+import {
+  type BlockEndStateField,
+  decodeBlockEndStateField,
+  encodeBlockEndStateField,
+} from './block_end_state_field.js';
+import { type TxBlobData, decodeTxBlobData, encodeTxBlobData } from './tx_blob_data.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
+
+export const NUM_BLOCK_END_BLOB_FIELDS = 6;
+export const NUM_FIRST_BLOCK_END_BLOB_FIELDS = 7;
+export const NUM_CHECKPOINT_END_MARKER_FIELDS = 1;
+
+/**
+ * Returns the number of blob fields used for block end data.
+ * @param isFirstBlockInCheckpoint - Whether this is the first block in a checkpoint.
+ */
+export function getNumBlockEndBlobFields(isFirstBlockInCheckpoint: boolean): number {
+  return isFirstBlockInCheckpoint ? NUM_FIRST_BLOCK_END_BLOB_FIELDS : NUM_BLOCK_END_BLOB_FIELDS;
+}
+
+export interface BlockEndBlobData {
+  blockEndMarker: BlockEndMarker;
+  blockEndStateField: BlockEndStateField;
+  lastArchiveRoot: Fr;
+  noteHashRoot: Fr;
+  nullifierRoot: Fr;
+  publicDataRoot: Fr;
+  l1ToL2MessageRoot: Fr | undefined;
+}
+
+export interface BlockBlobData extends BlockEndBlobData {
+  txs: TxBlobData[];
+}
+
+export function encodeBlockEndBlobData(blockEndBlobData: BlockEndBlobData): Fr[] {
+  return [
+    encodeBlockEndMarker(blockEndBlobData.blockEndMarker),
+    encodeBlockEndStateField(blockEndBlobData.blockEndStateField),
+    blockEndBlobData.lastArchiveRoot,
+    blockEndBlobData.noteHashRoot,
+    blockEndBlobData.nullifierRoot,
+    blockEndBlobData.publicDataRoot,
+    ...(blockEndBlobData.l1ToL2MessageRoot ? [blockEndBlobData.l1ToL2MessageRoot] : []),
+  ];
+}
+
+export function decodeBlockEndBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockEndBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  const numBlockEndData = getNumBlockEndBlobFields(isFirstBlock);
+  if (numBlockEndData > reader.remainingFields()) {
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: not enough fields for block end data. Expected ${numBlockEndData} fields, only ${reader.remainingFields()} remaining.`,
+    );
+  }
+
+  return {
+    blockEndMarker: decodeBlockEndMarker(reader.readField()),
+    blockEndStateField: decodeBlockEndStateField(reader.readField()),
+    lastArchiveRoot: reader.readField(),
+    noteHashRoot: reader.readField(),
+    nullifierRoot: reader.readField(),
+    publicDataRoot: reader.readField(),
+    l1ToL2MessageRoot: isFirstBlock ? reader.readField() : undefined,
+  };
+}
+
+export function encodeBlockBlobData(blockBlobData: BlockBlobData): Fr[] {
+  return [...blockBlobData.txs.map(tx => encodeTxBlobData(tx)).flat(), ...encodeBlockEndBlobData(blockBlobData)];
+}
+
+export function decodeBlockBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  const txs: TxBlobData[] = [];
+  let hasReachedBlockEnd = false;
+  while (!hasReachedBlockEnd) {
+    if (reader.isFinished()) {
+      throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for block end marker.`);
+    }
+
+    const currentField = reader.peekField();
+    if (isBlockEndMarker(currentField)) {
+      hasReachedBlockEnd = true;
+    } else {
+      txs.push(decodeTxBlobData(reader));
+    }
+  }
+
+  const blockEndBlobData = decodeBlockEndBlobData(reader, isFirstBlock);
+
+  const blockEndMarker = blockEndBlobData.blockEndMarker;
+  if (blockEndMarker.numTxs !== txs.length) {
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: expected ${blockEndMarker.numTxs} txs, but got ${txs.length}.`,
+    );
+  }
+
+  return {
+    txs,
+    ...blockEndBlobData,
+  };
+}

package/src/encoding/block_end_marker.ts

@@ -0,0 +1,55 @@
+import { BLOCK_END_PREFIX } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
+
+const BLOCK_NUMBER_BIT_SIZE = 32n;
+const TIMESTAMP_BIT_SIZE = 64n;
+const NUM_TXS_BIT_SIZE = 16n;
+
+export interface BlockEndMarker {
+  timestamp: bigint;
+  blockNumber: BlockNumber;
+  numTxs: number;
+}
+
+export function encodeBlockEndMarker(blockEndMarker: BlockEndMarker) {
+  let value = BigInt(BLOCK_END_PREFIX);
+  value <<= TIMESTAMP_BIT_SIZE;
+  value += blockEndMarker.timestamp;
+  value <<= BLOCK_NUMBER_BIT_SIZE;
+  value += BigInt(blockEndMarker.blockNumber);
+  value <<= NUM_TXS_BIT_SIZE;
+  value += BigInt(blockEndMarker.numTxs);
+  return new Fr(value);
+}
+
+export function decodeBlockEndMarker(field: Fr): BlockEndMarker {
+  let value = field.toBigInt();
+  const numTxs = Number(value & (2n ** NUM_TXS_BIT_SIZE - 1n));
+  value >>= NUM_TXS_BIT_SIZE;
+  const blockNumber = BlockNumber(Number(value & (2n ** BLOCK_NUMBER_BIT_SIZE - 1n)));
+  value >>= BLOCK_NUMBER_BIT_SIZE;
+  const timestamp = value & (2n ** TIMESTAMP_BIT_SIZE - 1n);
+  value >>= TIMESTAMP_BIT_SIZE;
+
+  const prefix = value;
+  if (prefix !== BigInt(BLOCK_END_PREFIX)) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid block end marker.`);
+  }
+
+  return {
+    blockNumber,
+    timestamp,
+    numTxs,
+  };
+}
+
+// Check if a field is a block end marker. Used before decoding to check if it has reached the end of the block.
+export function isBlockEndMarker(field: Fr): boolean {
+  const prefix = field.toBigInt() >> (NUM_TXS_BIT_SIZE + BLOCK_NUMBER_BIT_SIZE + TIMESTAMP_BIT_SIZE);
+  return prefix === BigInt(BLOCK_END_PREFIX);
+}

package/src/encoding/block_end_state_field.ts

@@ -0,0 +1,59 @@
+import {
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  NOTE_HASH_TREE_HEIGHT,
+  NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
+
+export const TOTAL_MANA_USED_BIT_SIZE = 48n;
+
+export interface BlockEndStateField {
+  l1ToL2MessageNextAvailableLeafIndex: number;
+  noteHashNextAvailableLeafIndex: number;
+  nullifierNextAvailableLeafIndex: number;
+  publicDataNextAvailableLeafIndex: number;
+  totalManaUsed: bigint;
+}
+
+export function encodeBlockEndStateField(blockEndStateField: BlockEndStateField) {
+  let value = BigInt(blockEndStateField.l1ToL2MessageNextAvailableLeafIndex);
+  value <<= BigInt(NOTE_HASH_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.noteHashNextAvailableLeafIndex);
+  value <<= BigInt(NULLIFIER_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.nullifierNextAvailableLeafIndex);
+  value <<= BigInt(PUBLIC_DATA_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.publicDataNextAvailableLeafIndex);
+  value <<= BigInt(TOTAL_MANA_USED_BIT_SIZE);
+  value += BigInt(blockEndStateField.totalManaUsed);
+  return new Fr(value);
+}
+
+export function decodeBlockEndStateField(field: Fr): BlockEndStateField {
+  let value = field.toBigInt();
+  const totalManaUsed = value & (2n ** TOTAL_MANA_USED_BIT_SIZE - 1n);
+  value >>= TOTAL_MANA_USED_BIT_SIZE;
+  const publicDataNextAvailableLeafIndex = Number(value & (2n ** BigInt(PUBLIC_DATA_TREE_HEIGHT) - 1n));
+  value >>= BigInt(PUBLIC_DATA_TREE_HEIGHT);
+  const nullifierNextAvailableLeafIndex = Number(value & (2n ** BigInt(NULLIFIER_TREE_HEIGHT) - 1n));
+  value >>= BigInt(NULLIFIER_TREE_HEIGHT);
+  const noteHashNextAvailableLeafIndex = Number(value & (2n ** BigInt(NOTE_HASH_TREE_HEIGHT) - 1n));
+  value >>= BigInt(NOTE_HASH_TREE_HEIGHT);
+
+  if (value > 2n ** BigInt(L1_TO_L2_MSG_TREE_HEIGHT) - 1n) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid block end state field.`);
+  }
+  const l1ToL2MessageNextAvailableLeafIndex = Number(value);
+
+  return {
+    l1ToL2MessageNextAvailableLeafIndex,
+    noteHashNextAvailableLeafIndex,
+    nullifierNextAvailableLeafIndex,
+    publicDataNextAvailableLeafIndex,
+    totalManaUsed,
+  };
+}

package/src/encoding/checkpoint_blob_data.ts

@@ -0,0 +1,102 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+import {
+  type BlockBlobData,
+  NUM_BLOCK_END_BLOB_FIELDS,
+  NUM_CHECKPOINT_END_MARKER_FIELDS,
+  NUM_FIRST_BLOCK_END_BLOB_FIELDS,
+  decodeBlockBlobData,
+  encodeBlockBlobData,
+} from './block_blob_data.js';
+import {
+  type CheckpointEndMarker,
+  decodeCheckpointEndMarker,
+  encodeCheckpointEndMarker,
+  isCheckpointEndMarker,
+} from './checkpoint_end_marker.js';
+import type { TxStartMarker } from './tx_start_marker.js';
+
+export interface CheckpointBlobData {
+  checkpointEndMarker: CheckpointEndMarker;
+  blocks: BlockBlobData[];
+}
+
+export function encodeCheckpointBlobData(checkpointBlobData: CheckpointBlobData): Fr[] {
+  return [
+    ...checkpointBlobData.blocks.map(block => encodeBlockBlobData(block)).flat(),
+    encodeCheckpointEndMarker(checkpointBlobData.checkpointEndMarker),
+  ];
+}
+
+export function encodeCheckpointBlobDataFromBlocks(blocks: BlockBlobData[]): Fr[] {
+  const blocksBlobFields = blocks.map(block => encodeBlockBlobData(block)).flat();
+  const numBlobFields = blocksBlobFields.length + NUM_CHECKPOINT_END_MARKER_FIELDS;
+  return blocksBlobFields.concat(encodeCheckpointEndMarker({ numBlobFields }));
+}
+
+export function decodeCheckpointBlobData(fields: Fr[] | FieldReader): CheckpointBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  if (reader.isFinished()) {
+    throw new BlobDeserializationError(`Cannot decode empty blob data.`);
+  }
+
+  const blocks = [];
+  let checkpointEndMarker: CheckpointEndMarker | undefined;
+  while (!reader.isFinished() && !checkpointEndMarker) {
+    blocks.push(decodeBlockBlobData(reader, blocks.length === 0 /* isFirstBlock */));
+
+    // After reading a block, the next item must be either a checkpoint end marker or another block.
+    // The first field of a block is always a tx start marker. So if the provided fields are valid, it's not possible to
+    // misinterpret a tx start marker as checkpoint end marker, or vice versa.
+    const nextField = reader.peekField();
+    if (isCheckpointEndMarker(nextField)) {
+      checkpointEndMarker = decodeCheckpointEndMarker(reader.readField());
+      const numFieldsRead = reader.cursor;
+      if (numFieldsRead !== checkpointEndMarker.numBlobFields) {
+        throw new BlobDeserializationError(
+          `Incorrect encoding of blob fields: mismatch number of blob fields. Expected ${checkpointEndMarker.numBlobFields} fields, got ${numFieldsRead}.`,
+        );
+      }
+    }
+  }
+
+  if (!checkpointEndMarker) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: checkpoint end marker does not exist.`);
+  }
+
+  const remainingFields = reader.readFieldArray(reader.remainingFields());
+  if (!remainingFields.every(f => f.isZero())) {
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: unexpected non-zero field after checkpoint end marker.`,
+    );
+  }
+
+  return {
+    checkpointEndMarker,
+    blocks,
+  };
+}
+
+export function decodeCheckpointBlobDataFromBuffer(buf: Buffer): CheckpointBlobData {
+  const reader = BufferReader.asReader(buf);
+  const totalFieldsInBuffer = Math.floor(buf.length / Fr.SIZE_IN_BYTES);
+  const blobFields = reader.readArray(totalFieldsInBuffer, Fr);
+  return decodeCheckpointBlobData(blobFields);
+}
+
+export function getTotalNumBlobFieldsFromTxs(txsPerBlock: TxStartMarker[][]): number {
+  const numBlocks = txsPerBlock.length;
+  if (!numBlocks) {
+    return 0;
+  }
+
+  return (
+    (numBlocks ? NUM_FIRST_BLOCK_END_BLOB_FIELDS - NUM_BLOCK_END_BLOB_FIELDS : 0) + // l1ToL2Messages root in the first block
+    numBlocks * NUM_BLOCK_END_BLOB_FIELDS + // 6 fields for each block end blob data.
+    txsPerBlock.reduce((total, txs) => total + txs.reduce((total, tx) => total + tx.numBlobFields, 0), 0) +
+    NUM_CHECKPOINT_END_MARKER_FIELDS // checkpoint end marker
+  );
+}

package/src/encoding/checkpoint_end_marker.ts

@@ -0,0 +1,40 @@
+import { CHECKPOINT_END_PREFIX } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/checkpoint_blob_data.nr`.
+
+const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
+
+export interface CheckpointEndMarker {
+  numBlobFields: number;
+}
+
+export function encodeCheckpointEndMarker(checkpointEndMarker: CheckpointEndMarker) {
+  let value = BigInt(CHECKPOINT_END_PREFIX);
+  value <<= NUM_BLOB_FIELDS_BIT_SIZE;
+  value += BigInt(checkpointEndMarker.numBlobFields);
+  return new Fr(value);
+}
+
+export function decodeCheckpointEndMarker(field: Fr): CheckpointEndMarker {
+  let value = field.toBigInt();
+  const numBlobFields = Number(value & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
+  value >>= NUM_BLOB_FIELDS_BIT_SIZE;
+
+  const prefix = value;
+  if (prefix !== BigInt(CHECKPOINT_END_PREFIX)) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid checkpoint end marker.`);
+  }
+
+  return {
+    numBlobFields,
+  };
+}
+
+// Check if a field is a checkpoint end marker. Used to check if it has reached the end of the blob fields.
+export function isCheckpointEndMarker(field: Fr): boolean {
+  const prefix = field.toBigInt() >> NUM_BLOB_FIELDS_BIT_SIZE;
+  return prefix === BigInt(CHECKPOINT_END_PREFIX);
+}