@aztec/foundation 0.72.1 → 0.73.0

package/src/blob/encoding.ts

@@ -0,0 +1,98 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+
+import type { Blob as BlobBuffer } from 'c-kzg';
+
+// 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;
+
+/**
+ * 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 deserializeEncodedBlobFields(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;
+    }
+
+    // Skip the remaining fields in this transaction
+    const len = getLengthFromFirstField(currentField);
+    fieldReader.skip(len);
+  }
+
+  // Return array up to last non-zero field
+  return array.slice(0, fieldReader.cursor);
+}
+
+export function getLengthFromFirstField(firstField: Fr): number {
+  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();
+}
+
+/**
+ * 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 the trimmed array
+  return array.slice(0, lastNonZeroIndex + 1);
+}

package/src/blob/index.ts

@@ -1,21 +1,12 @@
 import cKzg from 'c-kzg';
-import type { Blob as BlobBuffer } from 'c-kzg';
 
-import { poseidon2Hash, sha256 } from '../crypto/index.js';
-import { Fr } from '../fields/index.js';
-import { BufferReader, serializeToBuffer } from '../serialize/index.js';
-
-// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
 /* eslint-disable import/no-named-as-default-member */
+const { loadTrustedSetup } = cKzg;
 
-const {
-  BYTES_PER_BLOB,
-  FIELD_ELEMENTS_PER_BLOB,
-  blobToKzgCommitment,
-  computeKzgProof,
-  loadTrustedSetup,
-  verifyKzgProof,
-} = cKzg;
+export * from './blob.js';
+export * from './mocks.js';
+export * from './encoding.js';
+export * from './interface.js';
 
 try {
   loadTrustedSetup();
@@ -28,172 +19,3 @@ try {
     throw new Error(error);
   }
 }
-
-// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
-export const VERSIONED_HASH_VERSION_KZG = 0x01;
-
-/**
- * A class to create, manage, and prove EVM blobs.
- */
-export class Blob {
-  constructor(
-    /** The blob to be broadcast on L1 in bytes form. */
-    public readonly data: BlobBuffer,
-    /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
-    public readonly fieldsHash: Fr,
-    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
-    public readonly challengeZ: Fr,
-    /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
-    public readonly evaluationY: Buffer,
-    /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
-    public readonly commitment: Buffer,
-    /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
-    public readonly proof: Buffer,
-  ) {}
-
-  static fromFields(fields: Fr[], multiBlobFieldsHash?: Fr): Blob {
-    if (fields.length > FIELD_ELEMENTS_PER_BLOB) {
-      throw new Error(
-        `Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELD_ELEMENTS_PER_BLOB}`,
-      );
-    }
-    const dataWithoutZeros = serializeToBuffer(fields);
-    const data = Buffer.concat([dataWithoutZeros], BYTES_PER_BLOB);
-
-    // This matches the output of SpongeBlob.squeeze() in the blob circuit
-    const fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : poseidon2Hash(fields);
-    const commitment = Buffer.from(blobToKzgCommitment(data));
-    const challengeZ = poseidon2Hash([fieldsHash, ...commitmentToFields(commitment)]);
-    const res = computeKzgProof(data, challengeZ.toBuffer());
-    if (!verifyKzgProof(commitment, challengeZ.toBuffer(), res[1], res[0])) {
-      throw new Error(`KZG proof did not verify.`);
-    }
-    const proof = Buffer.from(res[0]);
-    const evaluationY = Buffer.from(res[1]);
-
-    return new Blob(dataWithoutZeros, fieldsHash, challengeZ, evaluationY, commitment, proof);
-  }
-
-  // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
-  commitmentToFields(): [Fr, Fr] {
-    return commitmentToFields(this.commitment);
-  }
-
-  // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
-  getEthVersionedBlobHash(): Buffer {
-    const hash = sha256(this.commitment);
-    hash[0] = VERSIONED_HASH_VERSION_KZG;
-    return hash;
-  }
-
-  static getEthVersionedBlobHash(commitment: Buffer): Buffer {
-    const hash = sha256(commitment);
-    hash[0] = VERSIONED_HASH_VERSION_KZG;
-    return hash;
-  }
-
-  toBuffer(): Buffer {
-    return Buffer.from(
-      serializeToBuffer(
-        this.data.length,
-        this.data,
-        this.fieldsHash,
-        this.challengeZ,
-        this.evaluationY.length,
-        this.evaluationY,
-        this.commitment.length,
-        this.commitment,
-        this.proof.length,
-        this.proof,
-      ),
-    );
-  }
-
-  static fromBuffer(buf: Buffer | BufferReader): Blob {
-    const reader = BufferReader.asReader(buf);
-    return new Blob(
-      reader.readUint8Array(),
-      reader.readObject(Fr),
-      reader.readObject(Fr),
-      reader.readBuffer(),
-      reader.readBuffer(),
-      reader.readBuffer(),
-    );
-  }
-
-  /**
-   * Pad the blob data to it's full size before posting
-   */
-  get dataWithZeros(): BlobBuffer {
-    return Buffer.concat([this.data], BYTES_PER_BLOB);
-  }
-
-  /**
-   * Get the size of the blob in bytes
-   */
-  getSize() {
-    return this.data.length;
-  }
-
-  // Returns a proof of opening of the blob 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] - proof (a commitment to the quotient polynomial q(X))
-  // See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
-  getEthBlobEvaluationInputs(): `0x${string}` {
-    const buf = Buffer.concat([
-      this.getEthVersionedBlobHash(),
-      this.challengeZ.toBuffer(),
-      this.evaluationY,
-      this.commitment,
-      this.proof,
-    ]);
-    return `0x${buf.toString('hex')}`;
-  }
-
-  static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}` {
-    let buf = Buffer.alloc(0);
-    blobs.forEach(blob => {
-      buf = Buffer.concat([
-        buf,
-        blob.getEthVersionedBlobHash(),
-        blob.challengeZ.toBuffer(),
-        blob.evaluationY,
-        blob.commitment,
-        blob.proof,
-      ]);
-    });
-    // For multiple blobs, we prefix the number of blobs:
-    const lenBuf = Buffer.alloc(1);
-    lenBuf.writeUint8(blobs.length);
-    buf = Buffer.concat([lenBuf, buf]);
-    return `0x${buf.toString('hex')}`;
-  }
-
-  static getViemKzgInstance() {
-    return {
-      blobToKzgCommitment: cKzg.blobToKzgCommitment,
-      computeBlobKzgProof: cKzg.computeBlobKzgProof,
-    };
-  }
-
-  // Returns as many blobs as we require to broadcast the given fields
-  // Assumes we share the fields hash between all blobs
-  static getBlobs(fields: Fr[]): Blob[] {
-    const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
-    const multiBlobFieldsHash = poseidon2Hash(fields);
-    const res = [];
-    for (let i = 0; i < numBlobs; i++) {
-      const end = fields.length < (i + 1) * FIELD_ELEMENTS_PER_BLOB ? fields.length : (i + 1) * FIELD_ELEMENTS_PER_BLOB;
-      res.push(Blob.fromFields(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
-    }
-    return res;
-  }
-}
-
-// 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
-function commitmentToFields(commitment: Buffer): [Fr, Fr] {
-  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, 48))];
-}

package/src/blob/interface.ts

@@ -0,0 +1,11 @@
+/**
+ * The relevant parts of a response from https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
+ */
+export interface BlobJson {
+  blob: string;
+  index?: number;
+  // eslint-disable-next-line camelcase
+  kzg_commitment: string;
+  // eslint-disable-next-line camelcase
+  kzg_proof: string;
+}

package/src/blob/mocks.ts

@@ -0,0 +1,30 @@
+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),
+    ]),
+  );
+}
+
+export function makeEncodedBlob(length: number): Promise<Blob> {
+  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
+}
+
+export function makeEncodedBlobFields(fields: Fr[]): Promise<Blob> {
+  return Blob.fromFields([encodeFirstField(fields.length + 1), ...fields]);
+}

package/src/config/env_var.ts

@@ -16,6 +16,8 @@ export type EnvVar =
   | 'BB_SKIP_CLEANUP'
   | 'BB_WORKING_DIRECTORY'
   | 'BOOTSTRAP_NODES'
+  | 'BLOB_SINK_PORT'
+  | 'BLOB_SINK_URL'
   | 'BOT_DA_GAS_LIMIT'
   | 'BOT_FEE_PAYMENT_METHOD'
   | 'BOT_FLUSH_SETUP_TRANSACTIONS'
@@ -51,7 +53,9 @@ export type EnvVar =
   | 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS'
   | 'INBOX_CONTRACT_ADDRESS'
   | 'L1_CHAIN_ID'
-  | 'L1_CONSENSUS_CLIENT_URL'
+  | 'L1_CONSENSUS_HOST_URL'
+  | 'L1_CONSENSUS_HOST_API_KEY'
+  | 'L1_CONSENSUS_HOST_API_KEY_HEADER'
   | 'L1_PRIVATE_KEY'
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
@@ -102,7 +106,6 @@ export type EnvVar =
   | 'P2P_UDP_LISTEN_ADDR'
   | 'P2P_ARCHIVED_TX_LIMIT'
   | 'PEER_ID_PRIVATE_KEY'
-  | 'PROVER_BLOB_SINK_URL'
   | 'PROOF_VERIFIER_L1_START_BLOCK'
   | 'PROOF_VERIFIER_POLL_INTERVAL_MS'
   | 'PROVER_AGENT_ENABLED'
@@ -142,7 +145,6 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
-  | 'SEQ_BLOB_SINK_URL'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
   | 'SEQ_MAX_TX_PER_BLOCK'
   | 'SEQ_MIN_TX_PER_BLOCK'
@@ -205,4 +207,5 @@ export type EnvVar =
   | 'FAUCET_L1_ASSETS'
   | 'K8S_POD_NAME'
   | 'K8S_POD_UID'
-  | 'K8S_NAMESPACE_NAME';
+  | 'K8S_NAMESPACE_NAME'
+  | 'CUSTOM_FORWARDER_CONTRACT_ADDRESS';

package/src/config/index.ts

@@ -9,6 +9,7 @@ export interface ConfigMapping {
   printDefault?: (val: any) => string;
   description: string;
   isBoolean?: boolean;
+  nested?: Record<string, ConfigMapping>;
 }
 
 export function isBooleanConfigValue<T>(obj: T, key: keyof T): boolean {
@@ -21,18 +22,15 @@ export function getConfigFromMappings<T>(configMappings: ConfigMappingsType<T>):
   const config = {} as T;
 
   for (const key in configMappings) {
-    if (configMappings[key]) {
-      const { env, parseEnv, defaultValue: def } = configMappings[key];
-      // Special case for L1 contract addresses which is an object of config values
-      if (key === 'l1Contracts' && def) {
-        (config as any)[key] = getConfigFromMappings(def);
-      } else {
-        const val = env ? process.env[env] : undefined;
-        if (val !== undefined) {
-          (config as any)[key] = parseEnv ? parseEnv(val) : val;
-        } else if (def !== undefined) {
-          (config as any)[key] = def;
-        }
+    const { env, parseEnv, defaultValue: def, nested } = configMappings[key];
+    if (nested) {
+      (config as any)[key] = getConfigFromMappings(nested);
+    } else {
+      const val = env ? process.env[env] : undefined;
+      if (val !== undefined) {
+        (config as any)[key] = parseEnv ? parseEnv(val) : val;
+      } else if (def !== undefined) {
+        (config as any)[key] = def;
       }
     }
   }

package/src/crypto/index.ts

@@ -1,5 +1,3 @@
-import { BarretenbergSync } from '@aztec/bb.js';
-
 export * from './keccak/index.js';
 export * from './random/index.js';
 export * from './sha256/index.js';
@@ -8,13 +6,3 @@ export * from './pedersen/index.js';
 export * from './poseidon/index.js';
 export * from './secp256k1-signer/index.js';
 export * from './keys/index.js';
-
-/**
- * Init the bb singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.
- * It takes about 100-200ms to initialize. It may not seem like much, but when in conjunction with many other things
- * initializing, developers may want to pick precisely when to incur this cost.
- * If in a test environment, we'll just do it on module load.
- */
-export async function init() {
-  await BarretenbergSync.initSingleton();
-}

package/src/crypto/keys/index.ts

@@ -2,8 +2,9 @@ import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 
-export function vkAsFieldsMegaHonk(input: Buffer): Fr[] {
-  return BarretenbergSync.getSingleton()
-    .acirVkAsFieldsMegaHonk(new RawBuffer(input))
-    .map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
+export async function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]> {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.acirVkAsFieldsMegaHonk(new RawBuffer(input));
+
+  return result.map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
 }

package/src/crypto/pedersen/pedersen.wasm.ts

@@ -7,12 +7,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * Create a pedersen commitment (point) from an array of input fields.
  * Left pads any inputs less than 32 bytes.
  */
-export function pedersenCommit(input: Buffer[], offset = 0) {
+export async function pedersenCommit(input: Buffer[], offset = 0) {
   if (!input.every(i => i.length <= 32)) {
     throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  const point = BarretenbergSync.getSingleton().pedersenCommit(
+  const api = await BarretenbergSync.initSingleton();
+  const point = api.pedersenCommit(
     input.map(i => new FrBarretenberg(i)),
     offset,
   );
@@ -27,23 +28,21 @@ export function pedersenCommit(input: Buffer[], offset = 0) {
  * @param index - The separator index to use for the hash.
  * @returns The pedersen hash.
  */
-export function pedersenHash(input: Fieldable[], index = 0): Fr {
+export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .pedersenHash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-          index,
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
  * Create a pedersen hash from an arbitrary length buffer.
  */
-export function pedersenHashBuffer(input: Buffer, index = 0) {
-  return Buffer.from(BarretenbergSync.getSingleton().pedersenHashBuffer(input, index).toBuffer());
+export async function pedersenHashBuffer(input: Buffer, index = 0) {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
 }

package/src/crypto/poseidon/index.ts

@@ -8,17 +8,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * @param input - The input fields to hash.
  * @returns The poseidon hash.
  */
-export function poseidon2Hash(input: Fieldable[]): Fr {
+export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
@@ -27,29 +23,22 @@ export function poseidon2Hash(input: Fieldable[]): Fr {
  * @param separator - The domain separator.
  * @returns The poseidon hash.
  */
-export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+export async function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Promise<Fr> {
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+
+  const hash = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
-export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+export async function poseidon2HashAccumulate(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())))
-        .toBuffer(),
-    ),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
 }
 
 /**
@@ -57,19 +46,18 @@ export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
  * @param input the input state. Expected to be of size 4.
  * @returns the output state, size 4.
  */
-export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+export async function poseidon2Permutation(input: Fieldable[]): Promise<Fr[]> {
   const inputFields = serializeToFields(input);
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(input.length === 4, 'Input state must be of size 4');
-  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.poseidon2Permutation(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(res.length === 4, 'Output state must be of size 4');
   return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
 }
 
-export function poseidon2HashBytes(input: Buffer): Fr {
+export async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
   const inputFields = [];
   for (let i = 0; i < input.length; i += 31) {
     const fieldBytes = Buffer.alloc(32, 0);
@@ -80,13 +68,10 @@ export function poseidon2HashBytes(input: Buffer): Fr {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
 }

package/src/crypto/sync/index.ts

@@ -0,0 +1,6 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+export * from './poseidon/index.js';
+export * from './pedersen/index.js';
+
+await BarretenbergSync.initSingleton();

package/src/crypto/sync/pedersen/index.ts

@@ -0,0 +1,45 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export function pedersenCommit(input: Buffer[], offset = 0) {
+  if (!input.every(i => i.length <= 32)) {
+    throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
+  }
+  input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
+  const point = BarretenbergSync.getSingleton().pedersenCommit(
+    input.map(i => new FrBarretenberg(i)),
+    offset,
+  );
+  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+  // TODO: rename toTypedArray()?
+  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
+}
+
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */
+export function pedersenHash(input: Fieldable[], index = 0): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export function pedersenHashBuffer(input: Buffer, index = 0) {
+  const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
+}