@aztec/blob-lib 0.76.4 → 0.77.0-testnet-ignition.17

package/src/blob_public_inputs.ts

@@ -0,0 +1,157 @@
+import { BLOBS_PER_BLOCK } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { toBigIntBE, toBufferBE, toHex } from '@aztec/foundation/bigint-buffer';
+import { sha256, sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { type Blob, VERSIONED_HASH_VERSION_KZG } from './blob.js';
+
+/**
+ * Public inputs required to be passed from our rollup circuits to verify a blob.
+ */
+export class BlobPublicInputs {
+  constructor(
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). */
+    public z: Fr,
+    /** Evaluation y = p(z), where p() is the blob polynomial. */
+    public y: bigint,
+    /** Commitment to the blob C. */
+    public kzgCommitment: Tuple<Fr, 2>,
+  ) {}
+
+  static empty(): BlobPublicInputs {
+    return new BlobPublicInputs(Fr.ZERO, 0n, [Fr.ZERO, Fr.ZERO]);
+  }
+
+  isEmpty(): boolean {
+    return this.z.isZero() && this.y == 0n && this.kzgCommitment[0].isZero() && this.kzgCommitment[1].isZero();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlobPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BlobPublicInputs(Fr.fromBuffer(reader), toBigIntBE(reader.readBytes(32)), reader.readArray(2, Fr));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlobPublicInputs.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): BlobPublicInputs {
+    const reader = FieldReader.asReader(fields);
+    // TODO: Create a BigNum to fields conversion we can use here and in type_conversion.ts
+    const fromBigNum = (fieldArr: Fr[]) => {
+      return BigInt(
+        fieldArr[2].toString().concat(fieldArr[1].toString().substring(2), fieldArr[0].toString().substring(2)),
+      );
+    };
+    return new BlobPublicInputs(reader.readField(), fromBigNum(reader.readFieldArray(3)), reader.readFieldArray(2));
+  }
+
+  // NB: y is NOT a BN254 field, it's a larger BLS field, we cannot use serialiseToFields here as it assumes bigints will fit
+  // TODO: Create a BigNum to fields conversion we can use here and in type_conversion.ts
+  toFields() {
+    const hex = toHex(this.y, true);
+    const bigNum = [
+      Fr.fromString('0x' + hex.substring(36)),
+      Fr.fromString('0x' + hex.substring(6, 36)),
+      Fr.fromString(hex.substring(0, 6)),
+    ];
+    return [this.z, ...bigNum, ...this.kzgCommitment];
+  }
+
+  static getFields(fields: FieldsOf<BlobPublicInputs>) {
+    return [fields.z, fields.y, fields.kzgCommitment] as const;
+  }
+
+  static fromBlob(input: Blob): BlobPublicInputs {
+    return new BlobPublicInputs(input.challengeZ, toBigIntBE(input.evaluationY), input.commitmentToFields());
+  }
+
+  getBlobHash(): Buffer {
+    const hash = sha256(this.commitmentToBuffer());
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+  }
+
+  // Performs the reverse conversion of blob.commitmentToFields()
+  // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
+  commitmentToBuffer(): Buffer {
+    return Buffer.concat([
+      this.kzgCommitment[0].toBuffer().subarray(1),
+      this.kzgCommitment[1].toBuffer().subarray(-17),
+    ]);
+  }
+
+  equals(other: BlobPublicInputs) {
+    return (
+      this.z.equals(other.z) &&
+      this.y == other.y &&
+      this.kzgCommitment[0].equals(other.kzgCommitment[0]) &&
+      this.kzgCommitment[1].equals(other.kzgCommitment[1])
+    );
+  }
+}
+
+// NB: it is much cleaner throughout the protocol circuits to define this struct rather than use a nested array.
+// Once we accumulate blob inputs, it should be removed, and we just use BlobPublicInputs::accumulate everywhere.
+export class BlockBlobPublicInputs {
+  constructor(public inner: Tuple<BlobPublicInputs, typeof BLOBS_PER_BLOCK>) {}
+
+  static empty(): BlockBlobPublicInputs {
+    return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, BlobPublicInputs.empty));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockBlobPublicInputs(reader.readArray(BLOBS_PER_BLOCK, BlobPublicInputs));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockBlobPublicInputs.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): BlockBlobPublicInputs {
+    const reader = FieldReader.asReader(fields);
+    return new BlockBlobPublicInputs(reader.readArray(BLOBS_PER_BLOCK, BlobPublicInputs));
+  }
+
+  toFields() {
+    return this.inner.map(i => i.toFields()).flat();
+  }
+
+  static getFields(fields: FieldsOf<BlockBlobPublicInputs>) {
+    return [fields.inner] as const;
+  }
+
+  static fromBlobs(inputs: Blob[]): BlockBlobPublicInputs {
+    const inner = makeTuple(BLOBS_PER_BLOCK, BlobPublicInputs.empty);
+    if (inputs.length > BLOBS_PER_BLOCK) {
+      throw new Error(`Can only fit ${BLOBS_PER_BLOCK} in one BlockBlobPublicInputs instance (given ${inputs.length})`);
+    }
+    inputs.forEach((input, i) => {
+      inner[i] = BlobPublicInputs.fromBlob(input);
+    });
+    return new BlockBlobPublicInputs(inner);
+  }
+
+  getBlobsHash() {
+    const blobHashes = this.inner.map(item => (item.isEmpty() ? Buffer.alloc(0) : item.getBlobHash()));
+    return sha256Trunc(serializeToBuffer(blobHashes));
+  }
+
+  // The below is used to send to L1 for proof verification
+  toString() {
+    const nonEmptyBlobs = this.inner.filter(item => !item.isEmpty());
+    // Write the number of blobs for L1 to verify
+    let buf = Buffer.alloc(1);
+    buf.writeUInt8(nonEmptyBlobs.length);
+    // Using standard toBuffer() does not correctly encode the commitment
+    // On L1, it's a 48 byte number, which we convert to 2 fields for use in the circuits
+    nonEmptyBlobs.forEach(blob => {
+      buf = Buffer.concat([buf, blob.z.toBuffer(), toBufferBE(blob.y, 32), blob.commitmentToBuffer()]);
+    });
+    return buf.toString('hex');
+  }
+}

package/src/encoding.ts

@@ -3,7 +3,7 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
 import type { Blob as BlobBuffer } from 'c-kzg';
 
-// Note duplicated from circuit-types !
+// 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
@@ -85,7 +85,6 @@ export function getLengthFromFirstField(firstField: Fr): number {
   return new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber();
 }
 
-// NOTE: duplicated from circuit-types tx effect!
 /**
  * Determines whether a field is the first field of a tx effect
  */

package/src/index.ts

@@ -4,10 +4,11 @@ import cKzg from 'c-kzg';
 const { loadTrustedSetup } = cKzg;
 
 export * from './blob.js';
-export * from './mocks.js';
 export * from './encoding.js';
 export * from './interface.js';
 export * from './errors.js';
+export * from './blob_public_inputs.js';
+export * from './sponge_blob.js';
 
 try {
   loadTrustedSetup();

package/src/sponge_blob.ts

@@ -0,0 +1,178 @@
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { poseidon2Permutation } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+
+/**
+ * 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 tx effects that will go into a blob. */
+    public readonly sponge: Poseidon2Sponge,
+    /** Number of effects absorbed so far. */
+    public fields: number,
+    /** Number of effects that will be absorbed. */
+    public readonly expectedFields: number,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob {
+    const reader = BufferReader.asReader(buffer);
+    return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber(), reader.readNumber());
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.sponge, this.fields, this.expectedFields);
+  }
+
+  static getFields(fields: FieldsOf<SpongeBlob>) {
+    return [fields.sponge, fields.fields, fields.expectedFields];
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...SpongeBlob.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): SpongeBlob {
+    const reader = FieldReader.asReader(fields);
+    return new SpongeBlob(
+      reader.readObject(Poseidon2Sponge),
+      reader.readField().toNumber(),
+      reader.readField().toNumber(),
+    );
+  }
+
+  clone() {
+    return SpongeBlob.fromBuffer(this.toBuffer());
+  }
+
+  async absorb(fields: Fr[]) {
+    if (this.fields + fields.length > this.expectedFields) {
+      throw new Error(
+        `Attempted to fill spongeblob with ${this.fields + fields.length}, but it has a max of ${this.expectedFields}`,
+      );
+    }
+    await this.sponge.absorb(fields);
+    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.fields != this.expectedFields) {
+      await this.sponge.absorb([Fr.ONE]);
+    }
+    return this.sponge.squeeze();
+  }
+
+  static empty(): SpongeBlob {
+    return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
+  }
+
+  static init(expectedFields: number): SpongeBlob {
+    return new SpongeBlob(Poseidon2Sponge.init(expectedFields), 0, expectedFields);
+  }
+}
+
+// This is just noir's stdlib version of the poseidon2 sponge. We use it for a blob-specific implmentation of the hasher.
+export class Poseidon2Sponge {
+  constructor(
+    public cache: Tuple<Fr, 3>,
+    public state: Tuple<Fr, 4>,
+    public cacheSize: number,
+    public squeezeMode: boolean,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): Poseidon2Sponge {
+    const reader = BufferReader.asReader(buffer);
+    return new Poseidon2Sponge(
+      reader.readArray(3, Fr),
+      reader.readArray(4, Fr),
+      reader.readNumber(),
+      reader.readBoolean(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.cache, this.state, this.cacheSize, this.squeezeMode);
+  }
+
+  static getFields(fields: FieldsOf<Poseidon2Sponge>) {
+    return [fields.cache, fields.state, fields.cacheSize, fields.squeezeMode];
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...Poseidon2Sponge.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): Poseidon2Sponge {
+    const reader = FieldReader.asReader(fields);
+    return new Poseidon2Sponge(
+      reader.readFieldArray(3),
+      reader.readFieldArray(4),
+      reader.readField().toNumber(),
+      reader.readBoolean(),
+    );
+  }
+
+  static empty(): Poseidon2Sponge {
+    return new Poseidon2Sponge(
+      makeTuple(3, () => Fr.ZERO),
+      makeTuple(4, () => Fr.ZERO),
+      0,
+      false,
+    );
+  }
+
+  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;
+  }
+
+  // Note: there isn't currently an impl in ts that allows for a custom aborption via an
+  // existing sponge.
+  // A custom blob-based impl of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr
+  async performDuplex() {
+    for (let i = 0; i < this.cache.length; i++) {
+      if (i < this.cacheSize) {
+        this.state[i] = this.state[i].add(this.cache[i]);
+      }
+    }
+    const perm = await poseidon2Permutation(this.state);
+    // ts doesn't understand that the above always gives 4
+    this.state = [perm[0], perm[1], perm[2], perm[3]];
+  }
+
+  async absorb(fields: Fr[]) {
+    if (this.squeezeMode) {
+      throw new Error(`Poseidon sponge is not able to absorb more inputs.`);
+    }
+    for (const field of fields) {
+      if (this.cacheSize == this.cache.length) {
+        await this.performDuplex();
+        this.cache[0] = field;
+        this.cacheSize = 1;
+      } else {
+        this.cache[this.cacheSize++] = field;
+      }
+    }
+  }
+
+  async squeeze(): Promise<Fr> {
+    if (this.squeezeMode) {
+      throw new Error(`Poseidon sponge has already been squeezed.`);
+    }
+    await this.performDuplex();
+    this.squeezeMode = true;
+    return this.state[0];
+  }
+}

package/src/testing.ts

@@ -0,0 +1,95 @@
+import { BLOBS_PER_BLOCK } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+
+import { Blob } from './blob.js';
+import { BlobPublicInputs, BlockBlobPublicInputs } from './blob_public_inputs.js';
+import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
+import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
+
+/**
+ * Makes arbitrary poseidon sponge for blob inputs.
+ * Note: will not verify inside the circuit.
+ * @param seed - The seed to use for generating the sponge.
+ * @returns A sponge blob instance.
+ */
+export function makeSpongeBlob(seed = 1): SpongeBlob {
+  return new SpongeBlob(
+    new Poseidon2Sponge(
+      makeTuple(3, i => new Fr(i)),
+      makeTuple(4, i => new Fr(i)),
+      1,
+      false,
+    ),
+    seed,
+    seed + 1,
+  );
+}
+
+/**
+ * Makes arbitrary blob public inputs.
+ * Note: will not verify inside the circuit.
+ * @param seed - The seed to use for generating the blob inputs.
+ * @returns A blob public inputs instance.
+ */
+export function makeBlobPublicInputs(seed = 1): BlobPublicInputs {
+  return new BlobPublicInputs(
+    new Fr(seed),
+    BigInt(seed + 1),
+    makeTuple(2, i => new Fr(i)),
+  );
+}
+
+/**
+ * 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 {
+  return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, () => makeBlobPublicInputs(seed)));
+}
+
+// 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),
+    ]),
+  );
+}
+
+/**
+ * Make an encoded blob with the given length
+ *
+ * This will deserialise correctly in the archiver
+ * @param length
+ * @returns
+ */
+export function makeEncodedBlob(length: number): Promise<Blob> {
+  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
+}
+
+/**
+ * Make an unencoded blob with the given length
+ *
+ * This will fail deserialisation in the archiver
+ * @param length
+ * @returns
+ */
+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/dest/mocks.d.ts

@@ -1,20 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { Blob } from './blob.js';
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export declare function makeEncodedBlob(length: number): Promise<Blob>;
-/**
- * Make an unencoded blob with the given length
- *
- * This will fail deserialisation in the archiver
- * @param length
- * @returns
- */
-export declare function makeUnencodedBlob(length: number): Promise<Blob>;
-export declare function makeEncodedBlobFields(fields: Fr[]): Promise<Blob>;
-//# sourceMappingURL=mocks.d.ts.map

package/dest/mocks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../src/mocks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAoBjC;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}

package/dest/mocks.js

@@ -1,42 +0,0 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
-import { Blob } from './blob.js';
-import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
-// TODO: copied form circuit-types tx effect
-function encodeFirstField(length) {
-    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),
-    ]));
-}
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export function makeEncodedBlob(length) {
-    return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
-}
-/**
- * Make an unencoded blob with the given length
- *
- * This will fail deserialisation in the archiver
- * @param length
- * @returns
- */
-export function makeUnencodedBlob(length) {
-    return Blob.fromFields([...Array.from({ length: length }, () => Fr.random())]);
-}
-export function makeEncodedBlobFields(fields) {
-    return Blob.fromFields([encodeFirstField(fields.length + 1), ...fields]);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbW9ja3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzdELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU5QyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFOUUsNENBQTRDO0FBQzVDLFNBQVMsZ0JBQWdCLENBQUMsTUFBYztJQUN0QyxNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2xDLFNBQVMsQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ25DLE9BQU8sSUFBSSxFQUFFLENBQ1gsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNaLFVBQVUsQ0FBQyxlQUFlLEVBQUUsNEJBQTRCLENBQUM7UUFDekQsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDZixTQUFTO1FBQ1QsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDZixNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDaEIsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDZixNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztLQUNoQixDQUFDLENBQ0gsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLE1BQWM7SUFDNUMsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxFQUFFLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDL0csQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FBQyxNQUFjO0lBQzlDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDakYsQ0FBQztBQUVELE1BQU0sVUFBVSxxQkFBcUIsQ0FBQyxNQUFZO0lBQ2hELE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDO0FBQzNFLENBQUMifQ==

package/src/mocks.ts

@@ -1,48 +0,0 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
-
-import { Blob } from './blob.js';
-import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
-
-// TODO: copied form circuit-types 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),
-    ]),
-  );
-}
-
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export function makeEncodedBlob(length: number): Promise<Blob> {
-  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
-}
-
-/**
- * Make an unencoded blob with the given length
- *
- * This will fail deserialisation in the archiver
- * @param length
- * @returns
- */
-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]);
-}