@aztec/blob-lib 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/src/encoding.ts

@@ -1,154 +1,138 @@
-import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { FieldReader } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
-const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
-const REVERT_CODE_BIT_SIZE = 8n;
-const NUM_NOTE_HASH_BIT_SIZE = 16n;
-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 PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
-const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
+import type { Blob as BlobBuffer } from 'c-kzg';
 
-export interface TxStartMarker {
-  prefix: bigint;
-  numBlobFields: number;
-  revertCode: number;
-  numNoteHashes: number;
-  numNullifiers: number;
-  numL2ToL1Msgs: number;
-  numPublicDataWrites: number;
-  numPrivateLogs: 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'>) {
-  let value = TX_START_PREFIX;
-  value <<= NUM_NOTE_HASH_BIT_SIZE;
-  value += BigInt(txStartMarker.numNoteHashes);
-  value <<= NUM_NULLIFIER_BIT_SIZE;
-  value += BigInt(txStartMarker.numNullifiers);
-  value <<= NUM_L2_TO_L1_MSG_BIT_SIZE;
-  value += BigInt(txStartMarker.numL2ToL1Msgs);
-  value <<= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
-  value += BigInt(txStartMarker.numPublicDataWrites);
-  value <<= NUM_PRIVATE_LOG_BIT_SIZE;
-  value += BigInt(txStartMarker.numPrivateLogs);
-  value <<= PUBLIC_LOGS_LENGTH_BIT_SIZE;
-  value += BigInt(txStartMarker.publicLogsLength);
-  value <<= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
-  value += BigInt(txStartMarker.contractClassLogLength);
-  value <<= REVERT_CODE_BIT_SIZE;
-  value += BigInt(txStartMarker.revertCode);
-  value <<= NUM_BLOB_FIELDS_BIT_SIZE;
-  value += BigInt(txStartMarker.numBlobFields);
-  return new Fr(value);
-}
-
-export function decodeTxStartMarker(field: Fr): TxStartMarker {
-  let value = field.toBigInt();
-  const numBlobFields = Number(value & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
-  value >>= NUM_BLOB_FIELDS_BIT_SIZE;
-  const revertCode = Number(value & (2n ** REVERT_CODE_BIT_SIZE - 1n));
-  value >>= REVERT_CODE_BIT_SIZE;
-  const contractClassLogLength = Number(value & (2n ** CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE - 1n));
-  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 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));
-  value >>= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
-  const numL2ToL1Msgs = Number(value & (2n ** NUM_L2_TO_L1_MSG_BIT_SIZE - 1n));
-  value >>= NUM_L2_TO_L1_MSG_BIT_SIZE;
-  const numNullifiers = Number(value & (2n ** NUM_NULLIFIER_BIT_SIZE - 1n));
-  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;
-  return {
-    prefix,
-    numBlobFields,
-    revertCode,
-    numNoteHashes,
-    numNullifiers,
-    numL2ToL1Msgs,
-    numPublicDataWrites,
-    numPrivateLogs,
-    publicLogsLength,
-    contractClassLogLength,
-  };
-}
-
-export function getNumBlobFieldsFromTxStartMarker(field: Fr) {
-  return Number(field.toBigInt() & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
-}
+// Note duplicated from stdlib !
+// This will appear as 0x74785f7374617274 in logs
+export const TX_START_PREFIX = 8392562855083340404n;
+// These are helper constants to decode tx effects from blob encoded fields
+export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
+// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
+export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
+export const REVERT_CODE_PREFIX = 1;
 
-export function isValidTxStartMarker(txStartMarker: TxStartMarker) {
-  return txStartMarker.prefix === TX_START_PREFIX;
-}
+/**
+ * Deserializes a blob buffer into an array of field elements.
+ *
+ * Blobs are converted into BN254 fields to perform a poseidon2 hash on them (fieldHash).
+ * This method is sparse, meaning it does not include trailing zeros at the end of the blob.
+ *
+ * However, we cannot simply trim the zero's from the end of the blob, as some logs may include zero's
+ * within them.
+ * If we end on a set of zeros, such as the log below:
+ * length 7: [ a, b, c, d, e, 0, 0]
+ *
+ * we will end up with the incorrect hash if we trim the zeros from the end.
+ *
+ * Each transactions logs contains a TX start prefix, which includes a string followed
+ * by the length ( in field elements ) of the transaction's log.
+ *
+ * This function finds the end of the last transaction's logs, and returns the array up to this point.
+ *
+ * We search for a series of Tx Prefixes progressing the cursor in the field reader until we hit
+ * a field that is not a Tx Prefix, this indicates that we have reached the end of the last transaction's logs.
+ *
+ * +------------------+------------------+------------------+------------------+
+ * | TX1 Start Prefix | TX1 Log Fields   | TX2 Start Prefix | Padded zeros     |
+ * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
+ * +------------------+------------------+------------------+------------------+
+ *                                                          ^
+ *                                                          |
+ * Function reads until here --------------------------------
+ *
+ * @param blob - The blob buffer to deserialize.
+ * @returns An array of field elements.
+ */
+export function deserializeEncodedBlobToFields(blob: BlobBuffer): Fr[] {
+  // Convert blob buffer to array of field elements
+  const reader = BufferReader.asReader(blob);
+  const array = reader.readArray(blob.length >> 5, Fr); // >> 5 = / 32 (bytes per field)
+  const fieldReader = FieldReader.asReader(array);
+
+  // Read fields until we hit zeros at the end
+  while (!fieldReader.isFinished()) {
+    const currentField = fieldReader.peekField();
+
+    // Stop when we hit a zero field
+    if (!currentField || currentField.isZero()) {
+      break;
+    }
 
-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));
-}
+    // Skip the remaining fields in this transaction
+    const len = getLengthFromFirstField(currentField);
+    fieldReader.skip(len);
+  }
 
-export function getNumTxsFromBlockEndMarker(field: Fr) {
-  return Number(field.toBigInt() & 0xffffn);
+  // Return array up to last non-zero field
+  return array.slice(0, fieldReader.cursor);
 }
 
-export function isBlockEndMarker(field: Fr) {
-  const value = field.toBigInt();
-  const numTxs = value & 0xffffn;
-  return value - numTxs === BLOCK_END_PREFIX * 256n * 256n;
+/**
+ * Get the length of the transaction from the first field.
+ *
+ * @param firstField - The first field of the transaction.
+ * @returns The length of the transaction.
+ *
+ * @throws If the first field does not include the correct prefix - encoding invalid.
+ */
+export function getLengthFromFirstField(firstField: Fr): number {
+  // Check that the first field includes the correct prefix
+  if (!isValidFirstField(firstField)) {
+    throw new Error('Invalid prefix');
+  }
+  const buf = firstField.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
+  return new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber();
 }
 
 /**
- * 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.
+ * Determines whether a field is the first field of a tx effect
  */
-export function checkBlobFieldsEncoding(blobFields: Fr[]) {
-  const reader = FieldReader.asReader(blobFields);
-
-  const checkpointPrefix = reader.readField();
-  if (checkpointPrefix.toBigInt() !== BigInt(blobFields.length)) {
+export function isValidFirstField(field: Fr): boolean {
+  const buf = field.toBuffer();
+  if (
+    !buf
+      .subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH)
+      .equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))
+  ) {
     return false;
   }
+  const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
+  if (
+    // Checking we start with the correct prefix...
+    !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) ||
+    // ...and include the revert code prefix..
+    sliced[sliced.length - 3] !== REVERT_CODE_PREFIX ||
+    // ...and the following revert code is valid.
+    sliced[sliced.length - 1] > 4
+  ) {
+    return false;
+  }
+  return true;
+}
 
-  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.
+/**
+ * Extract the fields from a blob buffer, but do not take into account encoding
+ * that will include trailing zeros.
+ *
+ * +------------------+------------------+------------------+------------------+
+ * |                  |                  |                  | Padded zeros     |
+ * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
+ * +------------------+------------------+------------------+------------------+
+ *                                                ^
+ *                                                |
+ * Function reads until here ----------------------
+ */
+export function extractBlobFieldsFromBuffer(blob: BlobBuffer): Fr[] {
+  const reader = BufferReader.asReader(blob);
+  const array = reader.readArray(blob.length >> 5, Fr);
+
+  // Find the index of the last non-zero field
+  let lastNonZeroIndex = array.length - 1;
+  while (lastNonZeroIndex >= 0 && array[lastNonZeroIndex].isZero()) {
+    lastNonZeroIndex--;
   }
 
-  return true;
+  // Return the trimmed array
+  return array.slice(0, lastNonZeroIndex + 1);
 }

package/src/index.ts

@@ -1,10 +1,23 @@
+import cKzg from 'c-kzg';
+
+const { loadTrustedSetup } = cKzg;
+
 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 './errors.js';
-export * from './hash.js';
 export * from './interface.js';
+export * from './errors.js';
+export * from './blob_batching_public_inputs.js';
 export * from './sponge_blob.js';
+
+try {
+  loadTrustedSetup(8); // See https://notes.ethereum.org/@jtraglia/windowed_multiplications
+} catch (error: any) {
+  if (error.message.includes('trusted setup is already loaded')) {
+    // NB: The c-kzg lib has no way of checking whether the setup is loaded or not,
+    // and it throws an error if it's already loaded, even though nothing is wrong.
+    // This is a rudimentary way of ensuring we load the trusted setup if we need it.
+  } else {
+    throw new Error(error);
+  }
+}

package/src/sponge_blob.ts

@@ -1,4 +1,3 @@
-import { TWO_POW_64 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { poseidon2Permutation } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
@@ -11,17 +10,17 @@ import {
 } from '@aztec/foundation/serialize';
 
 /**
- * A Poseidon2 sponge used to accumulate data that will be added to blobs.
+ * A Poseidon2 sponge used to accumulate data that will be added to a blob.
  * See noir-projects/noir-protocol-circuits/crates/types/src/abis/sponge_blob.nr.
  */
 export class SpongeBlob {
   constructor(
-    /** Sponge with absorbed fields that will go into one or more blobs. */
+    /** Sponge with absorbed tx effects that will go into a blob. */
     public readonly sponge: Poseidon2Sponge,
     /** Number of effects absorbed so far. */
-    public numAbsorbedFields: number,
+    public fields: number,
     /** Number of effects that will be absorbed. */
-    public readonly numExpectedFields: number,
+    public readonly expectedFields: number,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob {
@@ -30,11 +29,11 @@ export class SpongeBlob {
   }
 
   toBuffer() {
-    return serializeToBuffer(...SpongeBlob.getFields(this));
+    return serializeToBuffer(this.sponge, this.fields, this.expectedFields);
   }
 
   static getFields(fields: FieldsOf<SpongeBlob>) {
-    return [fields.sponge, fields.numAbsorbedFields, fields.numExpectedFields];
+    return [fields.sponge, fields.fields, fields.expectedFields];
   }
 
   toFields(): Fr[] {
@@ -55,19 +54,19 @@ export class SpongeBlob {
   }
 
   async absorb(fields: Fr[]) {
-    if (this.numAbsorbedFields + fields.length > this.numExpectedFields) {
+    if (this.fields + fields.length > this.expectedFields) {
       throw new Error(
-        `Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${this.numExpectedFields}`,
+        `Attempted to fill spongeblob with ${this.fields + fields.length}, but it has a max of ${this.expectedFields}`,
       );
     }
     await this.sponge.absorb(fields);
-    this.numAbsorbedFields += fields.length;
+    this.fields += fields.length;
   }
 
   async squeeze(): Promise<Fr> {
     // If the blob sponge is not 'full', we append 1 to match Poseidon2::hash_internal()
     // NB: There is currently no use case in which we don't 'fill' a blob sponge, but adding for completeness
-    if (this.numAbsorbedFields != this.numExpectedFields) {
+    if (this.fields != this.expectedFields) {
       await this.sponge.absorb([Fr.ONE]);
     }
     return this.sponge.squeeze();
@@ -77,17 +76,8 @@ export class SpongeBlob {
     return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
   }
 
-  /**
-   * Initialize the sponge blob with the number of expected fields in the checkpoint and absorb it as the first field.
-   * Note: `numExpectedFields` includes the first field absorbed in this method.
-   */
-  static async init(numExpectedFields: number): Promise<SpongeBlob> {
-    // This must match what the checkpoint root rollup circuit expects.
-    // See noir-projects/noir-protocol-circuits/types/src/abis/sponge_blob.nr -> init_for_checkpoint.
-    const sponge = Poseidon2Sponge.init(numExpectedFields);
-    await sponge.absorb([new Fr(numExpectedFields)]);
-    const numAbsorbedFields = 1;
-    return new SpongeBlob(sponge, numAbsorbedFields, numExpectedFields);
+  static init(expectedFields: number): SpongeBlob {
+    return new SpongeBlob(Poseidon2Sponge.init(expectedFields), 0, expectedFields);
   }
 }
 
@@ -141,8 +131,8 @@ export class Poseidon2Sponge {
     );
   }
 
-  static init(numExpectedFields: number): Poseidon2Sponge {
-    const iv = new Fr(numExpectedFields).mul(new Fr(TWO_POW_64));
+  static init(expectedFields: number): Poseidon2Sponge {
+    const iv = new Fr(expectedFields).mul(new Fr(BigInt('18446744073709551616')));
     const sponge = Poseidon2Sponge.empty();
     sponge.state[3] = iv;
     return sponge;

package/src/testing.ts

@@ -1,13 +1,11 @@
-import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { randomInt } from '@aztec/foundation/crypto';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 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 { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
+import { BlobAccumulatorPublicInputs, BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
+import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 
 /**
@@ -48,44 +46,36 @@ 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),
-  ];
+/**
+ * Makes arbitrary block blob public inputs.
+ * Note: will not verify inside the circuit.
+ * @param seed - The seed to use for generating the blob inputs.
+ * @returns A block blob public inputs instance.
+ */
+export function makeBlockBlobPublicInputs(seed = 1): BlockBlobPublicInputs {
+  const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
+  return new BlockBlobPublicInputs(
+    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(startBlobAccumulator),
+    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 1)),
+    startBlobAccumulator.finalBlobChallenges,
+  );
 }
 
-// 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.
+// TODO: copied form stdlib tx effect
+function encodeFirstField(length: number): Fr {
+  const lengthBuf = Buffer.alloc(2);
+  lengthBuf.writeUInt16BE(length, 0);
+  return new Fr(
+    Buffer.concat([
+      toBufferBE(TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH),
+      Buffer.alloc(1),
+      lengthBuf,
+      Buffer.alloc(1),
+      Buffer.from([1]),
+      Buffer.alloc(1),
+      Buffer.alloc(1),
+    ]),
+  );
 }
 
 /**
@@ -95,26 +85,21 @@ export function makeEncodedBlobFields(length: number): Fr[] {
  * @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);
+export function makeEncodedBlob(length: number): Promise<Blob> {
+  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
 }
 
 /**
- * Make a blob with random fields.
+ * Make an unencoded blob with the given length
  *
  * This will fail deserialisation in the archiver
  * @param length
  * @returns
  */
-export function makeRandomBlob(length: number): Blob {
+export function makeUnencodedBlob(length: number): Promise<Blob> {
   return Blob.fromFields([...Array.from({ length: length }, () => Fr.random())]);
 }
+
+export function makeEncodedBlobFields(fields: Fr[]): Promise<Blob> {
+  return Blob.fromFields([encodeFirstField(fields.length + 1), ...fields]);
+}

package/src/types.ts

@@ -1,7 +1,7 @@
-export * from './circuit_types/index.js';
-export * from './interface.js';
 export * from './sponge_blob.js';
 
+// TODO: Separate functions that use c-kzg from classes and export those classes here.
+
 /**
  * Type definition for the KZG instance returned by Blob.getViemKzgInstance().
  * Contains the cryptographic functions needed for blob commitment and proof generation.

package/dest/blob_utils.d.ts

@@ -1,30 +0,0 @@
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
-import { Blob } from './blob.js';
-/**
- * @param blobs - The blobs to emit.
- * @returns The blobs' compressed commitments in hex prefixed by the number of blobs. 1 byte for the prefix, 48 bytes
- * per blob commitment.
- * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs.
- */
-export declare function getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}`;
-/**
- * @param fields - Fields to broadcast in the blob(s)
- * @returns As many blobs as required to broadcast the given fields to an L1 block.
- *
- * @throws If the number of fields does not match what's indicated by the checkpoint prefix.
- */
-export declare function getBlobsPerL1Block(fields: Fr[]): 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.
- */
-export declare function getBlobFieldsInCheckpoint(blobs: Blob[], checkEncoding?: boolean): Fr[];
-export declare function computeBlobFieldsHashFromBlobs(blobs: Blob[]): Promise<Fr>;
-export declare function computeBlobsHashFromBlobs(blobs: Blob[]): Fr;
-export declare function getBlobCommitmentsFromBlobs(blobs: Blob[]): BLS12Point[];
-//# sourceMappingURL=blob_utils.d.ts.map

package/dest/blob_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blob_utils.d.ts","sourceRoot":"","sources":["../src/blob_utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE,CAS1E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,CASvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,aAAa,UAAQ,GAAG,EAAE,EAAE,CAEpF;AAED,wBAAsB,8BAA8B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAQ/E;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAE3D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAEvE"}

package/dest/blob_utils.js

@@ -1,60 +0,0 @@
-import { FIELDS_PER_BLOB } from '@aztec/constants';
-import { BLS12Point } from '@aztec/foundation/fields';
-import { Blob } from './blob.js';
-import { deserializeEncodedBlobToFields } from './deserialize.js';
-import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
-/**
- * @param blobs - The blobs to emit.
- * @returns The blobs' compressed commitments in hex prefixed by the number of blobs. 1 byte for the prefix, 48 bytes
- * per blob commitment.
- * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs.
- */ export function getPrefixedEthBlobCommitments(blobs) {
-    // Prefix the number of blobs.
-    const lenBuf = Buffer.alloc(1);
-    lenBuf.writeUint8(blobs.length);
-    const blobBuf = Buffer.concat(blobs.map((blob)=>blob.commitment));
-    const buf = Buffer.concat([
-        lenBuf,
-        blobBuf
-    ]);
-    return `0x${buf.toString('hex')}`;
-}
-/**
- * @param fields - Fields to broadcast in the blob(s)
- * @returns As many blobs as required to broadcast the given fields to an L1 block.
- *
- * @throws If the number of fields does not match what's indicated by the checkpoint prefix.
- */ export function getBlobsPerL1Block(fields) {
-    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)));
-}
-/**
- * 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.
- */ export function getBlobFieldsInCheckpoint(blobs, checkEncoding = false) {
-    return deserializeEncodedBlobToFields(Buffer.concat(blobs.map((b)=>b.data)), checkEncoding);
-}
-export async function computeBlobFieldsHashFromBlobs(blobs) {
-    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 computeBlobsHashFromBlobs(blobs) {
-    return computeBlobsHash(blobs.map((b)=>b.getEthVersionedBlobHash()));
-}
-export function getBlobCommitmentsFromBlobs(blobs) {
-    return blobs.map((b)=>BLS12Point.decompress(b.commitment));
-}

package/dest/circuit_types/blob_accumulator.d.ts

@@ -1,21 +0,0 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
-/**
- * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr` for documentation.
- */
-export declare class BlobAccumulator {
-    blobCommitmentsHashAcc: Fr;
-    zAcc: Fr;
-    yAcc: BLS12Fr;
-    cAcc: BLS12Point;
-    gammaAcc: Fr;
-    gammaPowAcc: BLS12Fr;
-    constructor(blobCommitmentsHashAcc: Fr, zAcc: Fr, yAcc: BLS12Fr, cAcc: BLS12Point, gammaAcc: Fr, gammaPowAcc: BLS12Fr);
-    static empty(): BlobAccumulator;
-    equals(other: BlobAccumulator): boolean;
-    static fromBuffer(buffer: Buffer | BufferReader): BlobAccumulator;
-    toBuffer(): Buffer<ArrayBufferLike>;
-    toFields(): Fr[];
-    static fromFields(fields: Fr[] | FieldReader): BlobAccumulator;
-}
-//# sourceMappingURL=blob_accumulator.d.ts.map

package/dest/circuit_types/blob_accumulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blob_accumulator.d.ts","sourceRoot":"","sources":["../../src/circuit_types/blob_accumulator.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F;;GAEG;AACH,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE,EAAE;IACZ,WAAW,EAAE,OAAO;gBALpB,sBAAsB,EAAE,EAAE,EAC1B,IAAI,EAAE,EAAE,EACR,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,OAAO;IAG7B,MAAM,CAAC,KAAK,IAAI,eAAe;IAI/B,MAAM,CAAC,KAAK,EAAE,eAAe;IAW7B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAYjE,QAAQ;IAWR,QAAQ;IAaR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe;CAe/D"}