@aztec/blob-lib 3.0.0-nightly.20251114 → 3.0.0-nightly.20251115

package/src/encoding/checkpoint_blob_data.ts

@@ -0,0 +1,75 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+import { type BlockBlobData, decodeBlockBlobData, encodeBlockBlobData } from './block_blob_data.js';
+import type { TxStartMarker } from './tx_start_marker.js';
+
+export interface CheckpointBlobData {
+  totalNumBlobFields: number;
+  blocks: BlockBlobData[];
+}
+
+export function encodeCheckpointBlobData(checkpointBlobData: CheckpointBlobData): Fr[] {
+  return [
+    new Fr(checkpointBlobData.totalNumBlobFields),
+    ...checkpointBlobData.blocks.map(block => encodeBlockBlobData(block)).flat(),
+  ];
+}
+
+export function decodeCheckpointBlobData(fields: Fr[] | FieldReader): CheckpointBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  if (reader.isFinished()) {
+    throw new BlobDeserializationError(`Cannot decode empty blob data.`);
+  }
+
+  const firstField = reader.readField();
+  // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error if the first field is
+  // larger than a javascript integer.
+  const totalNumBlobFields = firstField.toBigInt();
+  if (totalNumBlobFields > BigInt(reader.remainingFields() + 1)) {
+    // +1 because we already read the first field.
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: not enough fields for checkpoint blob data. Expected ${totalNumBlobFields} fields, got ${reader.remainingFields() + 1}.`,
+    );
+  }
+
+  const blocks = [];
+  while (reader.cursor < totalNumBlobFields) {
+    blocks.push(decodeBlockBlobData(reader, blocks.length === 0 /* isFirstBlock */));
+  }
+  return {
+    totalNumBlobFields: Number(totalNumBlobFields),
+    blocks,
+  };
+}
+
+export function decodeCheckpointBlobDataFromBuffer(buf: Buffer): CheckpointBlobData {
+  const reader = BufferReader.asReader(buf);
+  const firstField = reader.readObject(Fr);
+
+  // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error if the first field is
+  // larger than a javascript integer.
+  const numFields = firstField.toBigInt();
+  const totalFieldsInBuffer = BigInt(buf.length / Fr.SIZE_IN_BYTES);
+  if (numFields > totalFieldsInBuffer) {
+    throw new BlobDeserializationError(
+      `Failed to deserialize blob buffer: not enough fields for checkpoint blob data. Expected ${numFields} fields, got ${totalFieldsInBuffer}.`,
+    );
+  }
+
+  const numFieldsWithoutPrefix = Number(numFields) - 1;
+  const blobFields = [firstField].concat(reader.readArray(numFieldsWithoutPrefix, Fr));
+
+  return decodeCheckpointBlobData(blobFields);
+}
+
+export function getTotalNumBlobFieldsFromTxs(txs: TxStartMarker[][]): number {
+  return (
+    1 + // totalNumBlobFields
+    (txs.length ? 1 : 0) + // l1ToL2Messages root in the first block
+    txs.length * 6 + // 6 fields for each block end blob data.
+    txs.reduce((total, txs) => total + txs.reduce((total, tx) => total + tx.numBlobFields, 0), 0)
+  );
+}

package/src/encoding/fixtures.ts

@@ -0,0 +1,209 @@
+import {
+  FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { BlockBlobData, BlockEndBlobData } from './block_blob_data.js';
+import type { BlockEndMarker } from './block_end_marker.js';
+import type { BlockEndStateField } from './block_end_state_field.js';
+import { type CheckpointBlobData, getTotalNumBlobFieldsFromTxs } from './checkpoint_blob_data.js';
+import { type TxBlobData, getNumTxBlobFields } from './tx_blob_data.js';
+import type { TxStartMarker } from './tx_start_marker.js';
+
+const fr = (seed: number) => new Fr(BigInt(seed));
+
+export function makeTxStartMarker({
+  isFullTx = false,
+  ...overrides
+}: { isFullTx?: boolean } & Partial<TxStartMarker> = {}): TxStartMarker {
+  const partialTxStartMarker = {
+    revertCode: 0,
+    numNoteHashes: isFullTx ? MAX_NOTE_HASHES_PER_TX : 1,
+    numNullifiers: isFullTx ? MAX_NULLIFIERS_PER_TX : 1,
+    numL2ToL1Msgs: isFullTx ? MAX_L2_TO_L1_MSGS_PER_TX : 1,
+    numPublicDataWrites: isFullTx ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX : 1,
+    numPrivateLogs: isFullTx ? MAX_PRIVATE_LOGS_PER_TX : 1,
+    privateLogsLength: isFullTx ? PRIVATE_LOG_SIZE_IN_FIELDS * MAX_PRIVATE_LOGS_PER_TX : 1,
+    publicLogsLength: isFullTx ? FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH : 1,
+    contractClassLogLength: isFullTx ? MAX_CONTRACT_CLASS_LOGS_PER_TX : 1,
+    ...overrides,
+  };
+
+  const numBlobFields = overrides.numBlobFields ?? getNumTxBlobFields(partialTxStartMarker);
+  return {
+    ...partialTxStartMarker,
+    numBlobFields,
+  };
+}
+
+export function makeTxBlobData({
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: { isFullTx?: boolean; seed?: number } & Partial<
+  Omit<TxBlobData, 'txStartMarker'> & { txStartMarker?: Partial<TxStartMarker> }
+> = {}): TxBlobData {
+  const { txStartMarker: txStartMarkerOverrides, ...txBlobDataOverrides } = overrides;
+  const txStartMarker = makeTxStartMarker({ isFullTx, ...txStartMarkerOverrides });
+
+  const noteHashes = makeTuple(txStartMarker.numNoteHashes, fr, seed);
+  const nullifiers = makeTuple(txStartMarker.numNullifiers, fr, seed + 0x100);
+  const l2ToL1Msgs = makeTuple(txStartMarker.numL2ToL1Msgs, fr, seed + 0x200);
+  const publicDataWrites = makeTuple(
+    txStartMarker.numPublicDataWrites,
+    i => [fr(seed + i * 2), fr(seed + i * 2 + 1)] satisfies [Fr, Fr],
+    seed + 0x300,
+  );
+
+  const privateLogs = [];
+  if (txStartMarker.privateLogsLength > txStartMarker.numPrivateLogs * PRIVATE_LOG_SIZE_IN_FIELDS) {
+    throw new Error('Private logs length is too large');
+  }
+  if (txStartMarker.privateLogsLength < txStartMarker.numPrivateLogs) {
+    throw new Error('Private logs length is too small');
+  }
+  let remainingNumPrivateLogs = txStartMarker.numPrivateLogs;
+  let remainingPrivateLogsLength = txStartMarker.privateLogsLength;
+  for (let i = 0; i < txStartMarker.numPrivateLogs; i++) {
+    const minLength = Math.max(
+      1,
+      remainingPrivateLogsLength - (remainingNumPrivateLogs - 1) * PRIVATE_LOG_SIZE_IN_FIELDS,
+    );
+    const length = Math.max(minLength, Math.floor(remainingPrivateLogsLength / remainingNumPrivateLogs));
+    privateLogs.push(makeTuple(length, fr, seed + 0x400 + i * PRIVATE_LOG_SIZE_IN_FIELDS));
+    remainingNumPrivateLogs -= 1;
+    remainingPrivateLogsLength -= length;
+  }
+
+  const publicLogs = makeTuple(txStartMarker.publicLogsLength, fr, seed + 0x500);
+  const contractClassLogBlobDataLength =
+    txStartMarker.contractClassLogLength > 0 ? txStartMarker.contractClassLogLength + 1 : 0; // If the log exists, +1 for the contract address
+  const contractClassLog = makeTuple(contractClassLogBlobDataLength, fr, seed + 0x600);
+
+  return {
+    txStartMarker,
+    txHash: fr(seed + 0x700),
+    transactionFee: fr(seed + 0x800),
+    noteHashes,
+    nullifiers,
+    l2ToL1Msgs,
+    publicDataWrites,
+    privateLogs,
+    publicLogs,
+    contractClassLog,
+    ...txBlobDataOverrides,
+  };
+}
+
+export function makeBlockEndMarker({
+  seed = 1,
+  ...overrides
+}: { seed?: number } & Partial<BlockEndMarker> = {}): BlockEndMarker {
+  return {
+    numTxs: seed,
+    blockNumber: seed + 1,
+    timestamp: BigInt(seed + 2),
+    ...overrides,
+  };
+}
+
+export function makeBlockEndStateField({
+  seed = 1,
+  ...overrides
+}: { seed?: number } & Partial<BlockEndStateField> = {}): BlockEndStateField {
+  return {
+    l1ToL2MessageNextAvailableLeafIndex: seed,
+    noteHashNextAvailableLeafIndex: seed + 0x10,
+    nullifierNextAvailableLeafIndex: seed + 0x20,
+    publicDataNextAvailableLeafIndex: seed + 0x30,
+    totalManaUsed: BigInt(seed + 0x40),
+    ...overrides,
+  };
+}
+
+export function makeBlockEndBlobData({
+  isFirstBlock = true,
+  seed = 1,
+  ...overrides
+}: { seed?: number; isFirstBlock?: boolean } & Partial<
+  Omit<BlockEndBlobData, 'blockEndMarker' | 'blockEndStateField'>
+> & {
+    blockEndMarker?: Partial<BlockEndMarker>;
+    blockEndStateField?: Partial<BlockEndStateField>;
+  } = {}): BlockEndBlobData {
+  const {
+    blockEndMarker: blockEndMarkerOverrides,
+    blockEndStateField: blockEndStateFieldOverrides,
+    ...blockEndBlobDataOverrides
+  } = overrides;
+  return {
+    blockEndMarker: makeBlockEndMarker({ seed, ...blockEndMarkerOverrides }),
+    blockEndStateField: makeBlockEndStateField({ seed: seed + 0x100, ...blockEndStateFieldOverrides }),
+    lastArchiveRoot: fr(seed + 0x200),
+    noteHashRoot: fr(seed + 0x300),
+    nullifierRoot: fr(seed + 0x400),
+    publicDataRoot: fr(seed + 0x500),
+    l1ToL2MessageRoot: isFirstBlock ? fr(seed + 0x600) : undefined,
+    ...blockEndBlobDataOverrides,
+  };
+}
+
+export function makeBlockBlobData({
+  numTxs = 1,
+  isFirstBlock = true,
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: { numTxs?: number; isFirstBlock?: boolean; isFullTx?: boolean; seed?: number } & Partial<
+  Parameters<typeof makeBlockEndBlobData>[0]
+> = {}): BlockBlobData {
+  return {
+    txs: makeTuple(numTxs, i => makeTxBlobData({ isFullTx, seed: seed + i * 0x100 }), seed),
+    ...makeBlockEndBlobData({
+      seed: seed + 0x1000 * numTxs,
+      blockEndMarker: {
+        numTxs,
+      },
+      isFirstBlock,
+      ...overrides,
+    }),
+  };
+}
+
+export function makeCheckpointBlobData({
+  numBlocks = 1,
+  numTxsPerBlock = 1,
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: {
+  numBlocks?: number;
+  numTxsPerBlock?: number;
+  isFullTx?: boolean;
+  seed?: number;
+} & Partial<CheckpointBlobData> = {}): CheckpointBlobData {
+  const blocks =
+    overrides.blocks ??
+    makeTuple(
+      numBlocks,
+      i => makeBlockBlobData({ numTxs: numTxsPerBlock, isFirstBlock: i === seed, isFullTx, seed: seed + i * 0x1000 }),
+      seed,
+    );
+
+  const totalNumBlobFields =
+    overrides.totalNumBlobFields ??
+    getTotalNumBlobFieldsFromTxs(blocks.map(block => block.txs.map(tx => tx.txStartMarker)));
+
+  return {
+    totalNumBlobFields,
+    blocks,
+  };
+}

package/src/encoding/index.ts

@@ -0,0 +1,7 @@
+export * from './block_blob_data.js';
+export * from './block_end_marker.js';
+export * from './block_end_state_field.js';
+export * from './checkpoint_blob_data.js';
+export * from './fixtures.js';
+export * from './tx_blob_data.js';
+export * from './tx_start_marker.js';

package/src/encoding/tx_blob_data.ts

@@ -0,0 +1,116 @@
+import { chunk } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+import { type TxStartMarker, decodeTxStartMarker, encodeTxStartMarker } from './tx_start_marker.js';
+
+// Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr.
+
+export interface TxBlobData {
+  txStartMarker: TxStartMarker;
+  txHash: Fr;
+  transactionFee: Fr;
+  noteHashes: Fr[];
+  nullifiers: Fr[];
+  l2ToL1Msgs: Fr[];
+  publicDataWrites: [Fr, Fr][];
+  privateLogs: Fr[][];
+  publicLogs: Fr[];
+  contractClassLog: Fr[];
+}
+
+export function encodeTxBlobData(txBlobData: TxBlobData): Fr[] {
+  return [
+    encodeTxStartMarker(txBlobData.txStartMarker),
+    txBlobData.txHash,
+    txBlobData.transactionFee,
+    ...txBlobData.noteHashes,
+    ...txBlobData.nullifiers,
+    ...txBlobData.l2ToL1Msgs,
+    ...txBlobData.publicDataWrites.flat(),
+    ...txBlobData.privateLogs.map(log => [new Fr(log.length), ...log]).flat(),
+    ...txBlobData.publicLogs,
+    ...txBlobData.contractClassLog,
+  ];
+}
+
+export function decodeTxBlobData(fields: Fr[] | FieldReader): TxBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  if (reader.isFinished()) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for tx blob data.`);
+  }
+
+  const txStartMarker = decodeTxStartMarker(reader.readField());
+
+  const checkRemainingFields = (requiredFields: number, type: string) => {
+    if (requiredFields > reader.remainingFields()) {
+      throw new BlobDeserializationError(
+        `Incorrect encoding of blob fields: not enough fields for ${type}. Expected ${requiredFields} fields, only ${reader.remainingFields()} remaining.`,
+      );
+    }
+  };
+
+  const numTxEffectFields = txStartMarker.numBlobFields - 1; // -1 because we already read the tx start marker.
+  checkRemainingFields(numTxEffectFields, 'tx effect');
+
+  const txHash = reader.readField();
+  const transactionFee = reader.readField();
+
+  checkRemainingFields(txStartMarker.numNoteHashes, 'note hashes');
+  const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
+
+  checkRemainingFields(txStartMarker.numNullifiers, 'nullifiers');
+  const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
+
+  checkRemainingFields(txStartMarker.numL2ToL1Msgs, 'l2-to-l1 messages');
+  const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
+
+  checkRemainingFields(txStartMarker.numPublicDataWrites * 2, 'public data writes'); // *2 for leaf slot and value
+  const publicDataWrites = chunk(reader.readFieldArray(txStartMarker.numPublicDataWrites * 2), 2) as [Fr, Fr][];
+
+  const privateLogs = Array.from({ length: txStartMarker.numPrivateLogs }, () => {
+    const length = reader.readU32();
+    checkRemainingFields(length, 'private log');
+    return reader.readFieldArray(length);
+  });
+
+  checkRemainingFields(txStartMarker.publicLogsLength, 'public logs');
+  const publicLogs = reader.readFieldArray(txStartMarker.publicLogsLength);
+
+  const contractClassLogBlobDataLength =
+    txStartMarker.contractClassLogLength > 0 ? txStartMarker.contractClassLogLength + 1 : 0; // If the log exists, +1 for the contract address
+  checkRemainingFields(contractClassLogBlobDataLength, 'contract class logs');
+  const contractClassLog = reader.readFieldArray(contractClassLogBlobDataLength);
+
+  return {
+    txStartMarker,
+    txHash,
+    transactionFee,
+    noteHashes,
+    nullifiers,
+    l2ToL1Msgs,
+    publicDataWrites,
+    privateLogs,
+    publicLogs,
+    contractClassLog,
+  };
+}
+
+export function getNumTxBlobFields(txStartMarker: Omit<TxStartMarker, 'revertCode' | 'numBlobFields'>) {
+  return (
+    1 + // tx start marker
+    1 + // tx hash
+    1 + // transaction fee
+    txStartMarker.numNoteHashes +
+    txStartMarker.numNullifiers +
+    txStartMarker.numL2ToL1Msgs +
+    txStartMarker.numPublicDataWrites * 2 + // *2 for leaf slot and value per public data write
+    txStartMarker.numPrivateLogs + // +1 length field for each private log
+    txStartMarker.privateLogsLength +
+    txStartMarker.publicLogsLength +
+    txStartMarker.contractClassLogLength +
+    (txStartMarker.contractClassLogLength > 0 ? 1 : 0) // +1 for contract address of the contract class log
+  );
+}

package/src/{encoding.ts → encoding/tx_start_marker.ts}

@@ -1,6 +1,9 @@
-import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
+import { TX_START_PREFIX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
 
 const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
 const REVERT_CODE_BIT_SIZE = 8n;
@@ -9,11 +12,11 @@ const NUM_NULLIFIER_BIT_SIZE = 16n;
 const NUM_L2_TO_L1_MSG_BIT_SIZE = 16n;
 const NUM_PUBLIC_DATA_WRITE_BIT_SIZE = 16n;
 const NUM_PRIVATE_LOG_BIT_SIZE = 16n;
+const PRIVATE_LOGS_LENGTH_BIT_SIZE = 16n;
 const PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
 const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
 
 export interface TxStartMarker {
-  prefix: bigint;
   numBlobFields: number;
   revertCode: number;
   numNoteHashes: number;
@@ -21,12 +24,12 @@ export interface TxStartMarker {
   numL2ToL1Msgs: number;
   numPublicDataWrites: number;
   numPrivateLogs: number;
+  privateLogsLength: number;
   publicLogsLength: number;
   contractClassLogLength: number;
 }
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
-export function encodeTxStartMarker(txStartMarker: Omit<TxStartMarker, 'prefix'>) {
+export function encodeTxStartMarker(txStartMarker: TxStartMarker): Fr {
   let value = TX_START_PREFIX;
   value <<= NUM_NOTE_HASH_BIT_SIZE;
   value += BigInt(txStartMarker.numNoteHashes);
@@ -38,6 +41,8 @@ export function encodeTxStartMarker(txStartMarker: Omit<TxStartMarker, 'prefix'>
   value += BigInt(txStartMarker.numPublicDataWrites);
   value <<= NUM_PRIVATE_LOG_BIT_SIZE;
   value += BigInt(txStartMarker.numPrivateLogs);
+  value <<= PRIVATE_LOGS_LENGTH_BIT_SIZE;
+  value += BigInt(txStartMarker.privateLogsLength);
   value <<= PUBLIC_LOGS_LENGTH_BIT_SIZE;
   value += BigInt(txStartMarker.publicLogsLength);
   value <<= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
@@ -59,6 +64,8 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
   value >>= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
   const publicLogsLength = Number(value & (2n ** PUBLIC_LOGS_LENGTH_BIT_SIZE - 1n));
   value >>= PUBLIC_LOGS_LENGTH_BIT_SIZE;
+  const privateLogsLength = Number(value & (2n ** PRIVATE_LOGS_LENGTH_BIT_SIZE - 1n));
+  value >>= PRIVATE_LOGS_LENGTH_BIT_SIZE;
   const numPrivateLogs = Number(value & (2n ** NUM_PRIVATE_LOG_BIT_SIZE - 1n));
   value >>= NUM_PRIVATE_LOG_BIT_SIZE;
   const numPublicDataWrites = Number(value & (2n ** NUM_PUBLIC_DATA_WRITE_BIT_SIZE - 1n));
@@ -69,11 +76,13 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
   value >>= NUM_NULLIFIER_BIT_SIZE;
   const numNoteHashes = Number(value & (2n ** NUM_NOTE_HASH_BIT_SIZE - 1n));
   value >>= NUM_NOTE_HASH_BIT_SIZE;
-  // Do not throw if the prefix doesn't match.
-  // The caller function can check it by calling `isValidTxStartMarker`, and decide what to do if it's incorrect.
+
   const prefix = value;
+  if (prefix !== TX_START_PREFIX) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid tx start marker.`);
+  }
+
   return {
-    prefix,
     numBlobFields,
     revertCode,
     numNoteHashes,
@@ -81,74 +90,8 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
     numL2ToL1Msgs,
     numPublicDataWrites,
     numPrivateLogs,
+    privateLogsLength,
     publicLogsLength,
     contractClassLogLength,
   };
 }
-
-export function getNumBlobFieldsFromTxStartMarker(field: Fr) {
-  return Number(field.toBigInt() & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
-}
-
-export function isValidTxStartMarker(txStartMarker: TxStartMarker) {
-  return txStartMarker.prefix === TX_START_PREFIX;
-}
-
-export function createBlockEndMarker(numTxs: number) {
-  // Must match the implementation in `block_rollup_public_inputs_composer.nr > create_block_end_marker`.
-  return new Fr(BLOCK_END_PREFIX * 256n * 256n + BigInt(numTxs));
-}
-
-export function getNumTxsFromBlockEndMarker(field: Fr) {
-  return Number(field.toBigInt() & 0xffffn);
-}
-
-export function isBlockEndMarker(field: Fr) {
-  const value = field.toBigInt();
-  const numTxs = value & 0xffffn;
-  return value - numTxs === BLOCK_END_PREFIX * 256n * 256n;
-}
-
-/**
- * Check that the fields are emitted from the circuits and conform to the encoding.
- * @param blobFields - The concatenated fields from all blobs of an L1 block.
- */
-export function checkBlobFieldsEncoding(blobFields: Fr[]) {
-  const reader = FieldReader.asReader(blobFields);
-
-  const checkpointPrefix = reader.readField();
-  if (checkpointPrefix.toBigInt() !== BigInt(blobFields.length)) {
-    return false;
-  }
-
-  const numFieldsInCheckpoint = checkpointPrefix.toNumber();
-  let seenNumTxs = 0;
-  while (reader.cursor < numFieldsInCheckpoint) {
-    const currentField = reader.readField();
-
-    if (isBlockEndMarker(currentField)) {
-      // Found a block end marker. Confirm that the number of txs in this block is correct.
-      const numTxs = getNumTxsFromBlockEndMarker(currentField);
-      if (numTxs !== seenNumTxs) {
-        return false;
-      }
-      seenNumTxs = 0;
-      // Continue the loop to process the next field.
-      continue;
-    }
-
-    // If the field is not a block end marker, it must be a tx start marker.
-    const txStartMarker = decodeTxStartMarker(currentField);
-    if (!isValidTxStartMarker(txStartMarker)) {
-      return false;
-    }
-
-    seenNumTxs += 1;
-
-    // Skip the remaining fields in this tx. -1 because we already read the tx start marker.
-    reader.skip(txStartMarker.numBlobFields - 1);
-    // TODO: Check the encoding of the tx if we want to be more strict.
-  }
-
-  return true;
-}

package/src/index.ts

@@ -2,8 +2,7 @@ export * from './blob.js';
 export * from './blob_batching.js';
 export * from './blob_utils.js';
 export * from './circuit_types/index.js';
-export * from './deserialize.js';
-export * from './encoding.js';
+export * from './encoding/index.js';
 export * from './errors.js';
 export * from './hash.js';
 export * from './interface.js';

package/src/testing.ts

@@ -1,15 +1,13 @@
-import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { randomInt } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
 import { BatchedBlobAccumulator } from './blob_batching.js';
-import { getBlobsPerL1Block } from './blob_utils.js';
 import { FinalBlobBatchingChallenges } from './circuit_types/index.js';
-import { createBlockEndMarker, encodeTxStartMarker } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 
+export * from './encoding/fixtures.js';
+
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
  * Note: will not verify inside the circuit.
@@ -48,66 +46,6 @@ export function makeBatchedBlobAccumulator(seed = 1): BatchedBlobAccumulator {
   );
 }
 
-export function makeEncodedTxBlobFields(length: number): Fr[] {
-  const txStartMarker = {
-    numBlobFields: length,
-    // The rest of the values don't matter. The test components using it do not try to deserialize everything.
-    // Only `checkBlobFieldsEncoding` is used and it only looks at `numBlobFields`. This might change in the future
-    // when we add more thorough checks to `checkBlobFieldsEncoding`.
-    revertCode: 0,
-    numNoteHashes: 0,
-    numNullifiers: 0,
-    numL2ToL1Msgs: 0,
-    numPublicDataWrites: 0,
-    numPrivateLogs: 0,
-    publicLogsLength: 0,
-    contractClassLogLength: 0,
-  };
-
-  return [
-    encodeTxStartMarker(txStartMarker),
-    ...Array.from({ length: length - 1 }, () => new Fr(randomInt(Number.MAX_SAFE_INTEGER))), // -1 to account for the tx start marker.
-  ];
-}
-
-export function makeEncodedBlockBlobFields(...lengths: number[]): Fr[] {
-  return [
-    ...(lengths.length > 0 ? makeEncodedTxBlobFields(lengths[0] - 1) : []), // -1 to account for the block end marker.
-    ...lengths.slice(1).flatMap(length => makeEncodedTxBlobFields(length)),
-    createBlockEndMarker(lengths.length),
-  ];
-}
-
-// Create blob fields for a checkpoint with a single block.
-export function makeEncodedBlobFields(length: number): Fr[] {
-  if (length <= 2) {
-    throw new Error('Encoded blob fields length must be greater than 2');
-  }
-
-  const checkpointPrefix = new Fr(length);
-  return [checkpointPrefix, ...makeEncodedBlockBlobFields(length - 1)]; // -1 to account for the checkpoint prefix.
-}
-
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export function makeEncodedBlob(length: number): Blob {
-  if (length > FIELDS_PER_BLOB) {
-    throw new Error(`A single encoded blob must be less than ${FIELDS_PER_BLOB} fields`);
-  }
-
-  return Blob.fromFields(makeEncodedBlobFields(length));
-}
-
-export function makeEncodedBlobs(length: number): Blob[] {
-  const fields = makeEncodedBlobFields(length);
-  return getBlobsPerL1Block(fields);
-}
-
 /**
  * Make a blob with random fields.
  *

package/dest/deserialize.d.ts

@@ -1,14 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-/**
- * Deserializes a buffer into an array of field elements.
- *
- * This function returns the fields that were actually added in a checkpoint. The number of fields is specified by the
- * first field.
- *
- * @param buf - The buffer to deserialize.
- * @param checkEncoding - Whether to check if the encoding is correct. If false, it will still check the checkpoint
- * prefix and throw if there's not enough fields.
- * @returns An array of field elements.
- */
-export declare function deserializeEncodedBlobToFields(buf: Uint8Array, checkEncoding?: boolean): Fr[];
-//# sourceMappingURL=deserialize.d.ts.map

package/dest/deserialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deserialize.d.ts","sourceRoot":"","sources":["../src/deserialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAM9C;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,UAAQ,GAAG,EAAE,EAAE,CAoB3F"}