@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.0208eb9

package/src/barretenberg/__snapshots__/poseidon.test.ts.snap

@@ -0,0 +1,40 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`poseidon sync poseidonHash 1`] = `
+{
+  "hash": Uint8Array [
+    43,
+    202,
+    235,
+    109,
+    88,
+    187,
+    56,
+    186,
+    247,
+    83,
+    213,
+    140,
+    60,
+    150,
+    97,
+    143,
+    234,
+    130,
+    22,
+    51,
+    69,
+    41,
+    94,
+    180,
+    14,
+    136,
+    52,
+    78,
+    235,
+    12,
+    226,
+    161,
+  ],
+}
+`;

package/src/barretenberg/backend.test.ts

@@ -0,0 +1,122 @@
+import { fieldToString, fieldsToStrings } from './backend.js';
+
+describe('field helper functions', () => {
+  describe('fieldToString', () => {
+    it('converts zero field to "0"', () => {
+      const zeroField = new Uint8Array(32).fill(0);
+      expect(fieldToString(zeroField)).toBe('0');
+    });
+
+    it('converts field with value 1 to "1"', () => {
+      const oneField = new Uint8Array(32).fill(0);
+      oneField[31] = 1;
+      expect(fieldToString(oneField)).toBe('1');
+    });
+
+    it('converts field with value 256 to "256"', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[30] = 1;
+      field[31] = 0;
+      expect(fieldToString(field)).toBe('256');
+    });
+
+    it('converts field with max uint8 in last byte to "255"', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 255;
+      expect(fieldToString(field)).toBe('255');
+    });
+
+    it('converts larger values correctly', () => {
+      // 0x0100 = 256 in decimal
+      const field = new Uint8Array(32).fill(0);
+      field[30] = 0x01;
+      field[31] = 0x00;
+      expect(fieldToString(field)).toBe('256');
+    });
+
+    it('handles multi-byte values', () => {
+      // 0x010203 = 66051 in decimal
+      const field = new Uint8Array(32).fill(0);
+      field[29] = 0x01;
+      field[30] = 0x02;
+      field[31] = 0x03;
+      expect(fieldToString(field)).toBe('66051');
+    });
+
+    it('handles large field values', () => {
+      // A known value: all bytes set to 1
+      const field = new Uint8Array(32).fill(1);
+      const result = fieldToString(field);
+      // Verify it's a valid decimal string
+      expect(result).toMatch(/^\d+$/);
+      // Verify the length is reasonable for a 256-bit number
+      expect(result.length).toBeGreaterThan(70);
+    });
+
+    it('converts to hex with radix 16', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 255;
+      expect(fieldToString(field, 16)).toBe('ff');
+    });
+
+    it('converts to hex for multi-byte values', () => {
+      // 0x010203
+      const field = new Uint8Array(32).fill(0);
+      field[29] = 0x01;
+      field[30] = 0x02;
+      field[31] = 0x03;
+      expect(fieldToString(field, 16)).toBe('10203');
+    });
+
+    it('converts to binary with radix 2', () => {
+      const field = new Uint8Array(32).fill(0);
+      field[31] = 5;
+      expect(fieldToString(field, 2)).toBe('101');
+    });
+  });
+
+  describe('fieldsToStrings', () => {
+    it('converts empty array to empty array', () => {
+      expect(fieldsToStrings([])).toEqual([]);
+    });
+
+    it('converts single field', () => {
+      const oneField = new Uint8Array(32).fill(0);
+      oneField[31] = 42;
+      expect(fieldsToStrings([oneField])).toEqual(['42']);
+    });
+
+    it('converts multiple fields', () => {
+      const field1 = new Uint8Array(32).fill(0);
+      field1[31] = 1;
+
+      const field2 = new Uint8Array(32).fill(0);
+      field2[31] = 2;
+
+      const field3 = new Uint8Array(32).fill(0);
+      field3[31] = 3;
+
+      expect(fieldsToStrings([field1, field2, field3])).toEqual(['1', '2', '3']);
+    });
+
+    it('preserves order of fields', () => {
+      const fields = [10, 20, 30, 40, 50].map(v => {
+        const field = new Uint8Array(32).fill(0);
+        field[31] = v;
+        return field;
+      });
+
+      expect(fieldsToStrings(fields)).toEqual(['10', '20', '30', '40', '50']);
+    });
+
+    it('converts to hex with radix 16', () => {
+      const fields = [15, 16, 255].map(v => {
+        const field = new Uint8Array(32).fill(0);
+        field[31] = v;
+        return field;
+      });
+
+      expect(fieldsToStrings(fields, 16)).toEqual(['f', '10', 'ff']);
+    });
+  });
+});

package/src/barretenberg/backend.ts

@@ -0,0 +1,438 @@
+import { Barretenberg } from './index.js';
+import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
+import { fromChonkProof, toChonkProof, ChonkProof } from '../cbind/generated/api_types.js';
+import { ungzip } from 'pako';
+import { Decoder, Encoder } from 'msgpackr';
+
+export class AztecClientBackendError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+/**
+ * Target verification environment for proof generation.
+ * This determines the hash function used and whether zero-knowledge is enabled.
+ */
+export type VerifierTarget =
+  | 'evm' // Ethereum/Solidity verification (keccak, ZK enabled)
+  | 'evm-no-zk' // Ethereum/Solidity without zero-knowledge
+  | 'noir-recursive' // Recursive verification in Noir circuits (poseidon2, ZK enabled)
+  | 'noir-recursive-no-zk' // Recursive verification without ZK
+  | 'noir-rollup' // Rollup circuits with IPA accumulation (poseidon2, ZK enabled)
+  | 'noir-rollup-no-zk' // Rollup circuits without ZK
+  | 'starknet' // Starknet verification via Garaga (ZK enabled)
+  | 'starknet-no-zk'; // Starknet without zero-knowledge
+
+/**
+ * Options for the UltraHonkBackend.
+ */
+export type UltraHonkBackendOptions = {
+  /**
+   * Target verification environment. Determines hash function and ZK settings.
+   * This is the recommended way to configure proof generation.
+   *
+   * @example
+   * // For EVM/Solidity verification
+   * backend.generateProof(witness, { verifierTarget: 'evm' });
+   *
+   * // For recursive verification in Noir
+   * backend.generateProof(witness, { verifierTarget: 'noir-recursive' });
+   */
+  verifierTarget?: VerifierTarget;
+
+  // Legacy options - prefer using verifierTarget instead
+
+  /** @deprecated Use verifierTarget: 'evm-no-zk' instead */
+  keccak?: boolean;
+  /** @deprecated Use verifierTarget: 'evm' instead */
+  keccakZK?: boolean;
+  /** @deprecated Use verifierTarget: 'starknet-no-zk' instead */
+  starknet?: boolean;
+  /** @deprecated Use verifierTarget: 'starknet' instead */
+  starknetZK?: boolean;
+};
+
+function getProofSettingsFromOptions(options?: UltraHonkBackendOptions): {
+  ipaAccumulation: boolean;
+  oracleHashType: string;
+  disableZk: boolean;
+  optimizedSolidityVerifier: boolean;
+} {
+  // Check for conflicting options - verifierTarget should not be combined with legacy options
+  if (options?.verifierTarget) {
+    const legacyOptions = [options.keccak, options.keccakZK, options.starknet, options.starknetZK].filter(Boolean);
+    if (legacyOptions.length > 0) {
+      throw new Error(
+        'Cannot use verifierTarget with legacy options (keccak, keccakZK, starknet, starknetZK). ' +
+          'Use verifierTarget alone.',
+      );
+    }
+
+    switch (options.verifierTarget) {
+      case 'evm':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: false, optimizedSolidityVerifier: false };
+      case 'evm-no-zk':
+        return { ipaAccumulation: false, oracleHashType: 'keccak', disableZk: true, optimizedSolidityVerifier: false };
+      case 'noir-recursive':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-recursive-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'noir-rollup-no-zk':
+        return {
+          ipaAccumulation: true,
+          oracleHashType: 'poseidon2',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: false,
+          optimizedSolidityVerifier: false,
+        };
+      case 'starknet-no-zk':
+        return {
+          ipaAccumulation: false,
+          oracleHashType: 'starknet',
+          disableZk: true,
+          optimizedSolidityVerifier: false,
+        };
+    }
+  }
+
+  // Legacy options support (deprecated)
+  return {
+    ipaAccumulation: false,
+    oracleHashType:
+      options?.keccak || options?.keccakZK
+        ? 'keccak'
+        : options?.starknet || options?.starknetZK
+          ? 'starknet'
+          : 'poseidon2',
+    disableZk: options?.keccak || options?.starknet ? true : false,
+    optimizedSolidityVerifier: false,
+  };
+}
+
+export class UltraHonkVerifierBackend {
+  constructor(private api: Barretenberg) {}
+
+  async verifyProof(
+    proofData: ProofData & { verificationKey: Uint8Array },
+    options?: UltraHonkBackendOptions,
+  ): Promise<boolean> {
+    const proofFrs: Uint8Array[] = [];
+    for (let i = 0; i < proofData.proof.length; i += 32) {
+      proofFrs.push(proofData.proof.slice(i, i + 32));
+    }
+    const { verified } = await this.api.circuitVerify({
+      verificationKey: proofData.verificationKey,
+      publicInputs: proofData.publicInputs.map(hexToUint8Array),
+      proof: proofFrs,
+      settings: getProofSettingsFromOptions(options),
+    });
+    return verified;
+  }
+}
+
+export class UltraHonkBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  private acirUncompressedBytecode: Uint8Array;
+
+  constructor(
+    acirBytecode: string,
+    private api: Barretenberg,
+  ) {
+    this.acirUncompressedBytecode = acirToUint8Array(acirBytecode);
+  }
+
+  async generateProof(compressedWitness: Uint8Array, options?: UltraHonkBackendOptions): Promise<ProofData> {
+    const witness = ungzip(compressedWitness);
+    const { proof, publicInputs } = await this.api.circuitProve({
+      witness,
+      circuit: {
+        name: 'circuit',
+        bytecode: this.acirUncompressedBytecode,
+        verificationKey: new Uint8Array(0), // Empty VK - lower performance.
+      },
+      settings: getProofSettingsFromOptions(options),
+    });
+    console.log(`Generated proof for circuit with ${publicInputs.length} public inputs and ${proof.length} fields.`);
+
+    // We return ProofData as a flat buffer and an array of strings to match the current ProofData class.
+    const flatProof = new Uint8Array(proof.length * 32);
+    proof.forEach((fr, i) => {
+      flatProof.set(fr, i * 32);
+    });
+
+    return { proof: flatProof, publicInputs: publicInputs.map(uint8ArrayToHex) };
+  }
+
+  async verifyProof(proofData: ProofData, options?: UltraHonkBackendOptions): Promise<boolean> {
+    const proofFrs: Uint8Array[] = [];
+    for (let i = 0; i < proofData.proof.length; i += 32) {
+      proofFrs.push(proofData.proof.slice(i, i + 32));
+    }
+    // TODO reconsider API - computing the VK at this point is not optimal
+    const vkResult = await this.api.circuitComputeVk({
+      circuit: {
+        name: 'circuit',
+        bytecode: this.acirUncompressedBytecode,
+      },
+      settings: getProofSettingsFromOptions(options),
+    });
+    const { verified } = await this.api.circuitVerify({
+      verificationKey: vkResult.bytes,
+      publicInputs: proofData.publicInputs.map(hexToUint8Array),
+      proof: proofFrs,
+      settings: getProofSettingsFromOptions(options),
+    });
+    return verified;
+  }
+
+  async getVerificationKey(options?: UltraHonkBackendOptions): Promise<Uint8Array> {
+    const vkResult = await this.api.circuitComputeVk({
+      circuit: {
+        name: 'circuit',
+        bytecode: this.acirUncompressedBytecode,
+      },
+      settings: getProofSettingsFromOptions(options),
+    });
+    return vkResult.bytes;
+  }
+
+  /** @description Returns a solidity verifier */
+  async getSolidityVerifier(vk: Uint8Array, options?: UltraHonkBackendOptions): Promise<string> {
+    const result = await this.api.circuitWriteSolidityVerifier({
+      verificationKey: vk,
+      settings: getProofSettingsFromOptions(options),
+    });
+    return result.solidityCode;
+  }
+
+  // TODO(https://github.com/noir-lang/noir/issues/5661): Update this to handle Honk recursive aggregation in the browser once it is ready in the backend itself
+  async generateRecursiveProofArtifacts(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _proof: Uint8Array,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _numOfPublicInputs: number,
+    options?: UltraHonkBackendOptions,
+  ): Promise<{ proofAsFields: string[]; vkAsFields: string[]; vkHash: string }> {
+    // TODO(https://github.com/noir-lang/noir/issues/5661): This needs to be updated to handle recursive aggregation.
+    // There is still a proofAsFields method but we could consider getting rid of it as the proof itself
+    // is a list of field elements.
+    // UltraHonk also does not have public inputs directly prepended to the proof and they are still instead
+    // inserted at an offset.
+    // const proof = reconstructProofWithPublicInputs(proofData);
+    // const proofAsFields = (await this.api.acirProofAsFieldsUltraHonk(proof)).slice(numOfPublicInputs);
+
+    const vkResult = await this.api.circuitComputeVk({
+      circuit: {
+        name: 'circuit',
+        bytecode: this.acirUncompressedBytecode,
+      },
+      settings: getProofSettingsFromOptions(options),
+    });
+
+    // Convert VK bytes to field elements (32-byte chunks)
+    const vkAsFields: string[] = [];
+    for (let i = 0; i < vkResult.bytes.length; i += 32) {
+      const chunk = vkResult.bytes.slice(i, i + 32);
+      vkAsFields.push(uint8ArrayToHex(chunk));
+    }
+
+    return {
+      // TODO(https://github.com/noir-lang/noir/issues/5661)
+      proofAsFields: [],
+      vkAsFields,
+      // We use an empty string for the vk hash here as it is unneeded as part of the recursive artifacts
+      // The user can be expected to hash the vk inside their circuit to check whether the vk is the circuit
+      // they expect
+      vkHash: uint8ArrayToHex(vkResult.hash),
+    };
+  }
+}
+
+export class AztecClientBackend {
+  // These type assertions are used so that we don't
+  // have to initialize `api` in the constructor.
+  // These are initialized asynchronously in the `init` function,
+  // constructors cannot be asynchronous which is why we do this.
+
+  constructor(
+    private acirBuf: Uint8Array[],
+    private api: Barretenberg,
+  ) {}
+
+  async prove(witnessBuf: Uint8Array[], vksBuf: Uint8Array[] = []): Promise<[Uint8Array[], Uint8Array, Uint8Array]> {
+    if (vksBuf.length !== 0 && this.acirBuf.length !== witnessBuf.length) {
+      throw new AztecClientBackendError('Witness and bytecodes must have the same stack depth!');
+    }
+    if (vksBuf.length !== 0 && vksBuf.length !== witnessBuf.length) {
+      // NOTE: we allow 0 as an explicit 'I have no VKs'. This is a deprecated feature.
+      throw new AztecClientBackendError('Witness and VKs must have the same stack depth!');
+    }
+
+    // Queue IVC start with the number of circuits
+    this.api.chonkStart({ numCircuits: this.acirBuf.length });
+
+    // Queue load and accumulate for each circuit
+    for (let i = 0; i < this.acirBuf.length; i++) {
+      const bytecode = this.acirBuf[i];
+      const witness = witnessBuf[i] || new Uint8Array(0);
+      const vk = vksBuf[i] || new Uint8Array(0);
+      const functionName = `unknown_wasm_${i}`;
+
+      // Load the circuit
+      this.api.chonkLoad({
+        circuit: {
+          name: functionName,
+          bytecode: bytecode,
+          verificationKey: vk,
+        },
+      });
+
+      // Accumulate with witness
+      this.api.chonkAccumulate({
+        witness,
+      });
+    }
+
+    // Generate the proof (and wait for all previous steps to finish)
+    const proveResult = await this.api.chonkProve({});
+    // The API currently expects a msgpack-encoded API.
+    const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
+    // Generate the VK
+    const vkResult = await this.api.chonkComputeVk({
+      circuit: {
+        name: 'hiding',
+        bytecode: this.acirBuf[this.acirBuf.length - 1],
+      },
+    });
+
+    const proofFields = [
+      proveResult.proof.megaProof,
+      proveResult.proof.goblinProof.mergeProof,
+      proveResult.proof.goblinProof.eccvmProof,
+      proveResult.proof.goblinProof.ipaProof,
+      proveResult.proof.goblinProof.translatorProof,
+    ].flat();
+
+    // Verify using native proof directly to avoid redundant encode/decode cycle
+    if (!(await this.verifyNative(proveResult.proof, vkResult.bytes))) {
+      throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
+    }
+    return [proofFields, proof, vkResult.bytes];
+  }
+
+  async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
+    const result = await this.api.chonkVerify({
+      proof: toChonkProof(new Decoder({ useRecords: false }).decode(proof)),
+      vk,
+    });
+    return result.valid;
+  }
+
+  /**
+   * Internal verification using native ChonkProof type.
+   * Avoids encode/decode cycle when called from prove().
+   */
+  private async verifyNative(proof: ChonkProof, vk: Uint8Array): Promise<boolean> {
+    const result = await this.api.chonkVerify({
+      proof,
+      vk,
+    });
+    return result.valid;
+  }
+
+  async gates(): Promise<number[]> {
+    const circuitSizes: number[] = [];
+    for (const buf of this.acirBuf) {
+      const gates = await this.api.chonkStats({
+        circuit: {
+          name: 'circuit',
+          bytecode: buf,
+        },
+        includeGatesPerOpcode: false,
+      });
+      circuitSizes.push(gates.circuitSize);
+    }
+    return circuitSizes;
+  }
+}
+
+// Converts bytecode from a base64 string to a Uint8Array
+function acirToUint8Array(base64EncodedBytecode: string): Uint8Array {
+  const compressedByteCode = base64Decode(base64EncodedBytecode);
+  return ungzip(compressedByteCode);
+}
+
+// Base64 decode using atob (works in both browser and Node.js 18+)
+function base64Decode(input: string): Uint8Array {
+  if (typeof atob === 'function') {
+    return Uint8Array.from(atob(input), c => c.charCodeAt(0));
+  } else {
+    throw new Error('atob is not available. Node.js 18+ or browser required.');
+  }
+}
+
+/**
+ * Convert a field element (32-byte Uint8Array) to a string.
+ *
+ * @param field - A 32-byte field element
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns The field value as a string in the specified radix
+ *
+ * @example
+ * const decimal = fieldToString(field);        // "12345678"
+ * const hex = fieldToString(field, 16);        // "bc614e"
+ */
+export function fieldToString(field: Uint8Array, radix: number = 10): string {
+  let result = 0n;
+  for (const byte of field) {
+    result <<= 8n;
+    result += BigInt(byte);
+  }
+  return result.toString(radix);
+}
+
+/**
+ * Convert an array of field elements to an array of strings.
+ * Useful for passing VK fields to Noir circuits.
+ *
+ * @param fields - Array of 32-byte field elements
+ * @param radix - The radix for string conversion (2-36), defaults to 10 (decimal)
+ * @returns Array of strings in the specified radix
+ *
+ * @example
+ * const vkAsFields = await barretenbergAPI.vkAsFields({ verificationKey: vk });
+ * const vkDecimalStrings = fieldsToStrings(vkAsFields.fields);      // ["12345678", "87654321", ...]
+ * const vkHexStrings = fieldsToStrings(vkAsFields.fields, 16);      // ["bc614e", "5397fb1", ...]
+ */
+export function fieldsToStrings(fields: Uint8Array[], radix: number = 10): string[] {
+  return fields.map(field => fieldToString(field, radix));
+}
+

package/src/barretenberg/blake2s.test.ts

@@ -0,0 +1,69 @@
+import { BackendType, Barretenberg, BarretenbergSync } from './index.js';
+import { Fr } from './testing/fields.js';
+
+describe('blake2s async', () => {
+  let api: Barretenberg;
+
+  beforeAll(async () => {
+    // We're going to test over a worker backend to cover more code paths.
+    api = await Barretenberg.new({ threads: 1, backend: BackendType.WasmWorker });
+  });
+
+  afterAll(async () => {
+    await api.destroy();
+  });
+
+  it('blake2s', async () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = new Uint8Array([
+      0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c, 0x2a,
+      0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+    ]);
+    const response = await api.blake2s({ data: input });
+    expect(response.hash).toEqual(expected);
+  });
+
+  it('blake2sToField', async () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Fr.fromBufferReduce(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const response = await api.blake2sToField({ data: input });
+    const result = Fr.fromBuffer(response.field);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('blake2s sync', () => {
+  let api: BarretenbergSync;
+
+  beforeAll(async () => {
+    api = await BarretenbergSync.initSingleton();
+  });
+
+  it('blake2s', () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = new Uint8Array([
+      0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c, 0x2a,
+      0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+    ]);
+    const response = api.blake2s({ data: input });
+    expect(response.hash).toEqual(expected);
+  });
+
+  it('blake2sToField', () => {
+    const input = Buffer.from('abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789');
+    const expected = Fr.fromBufferReduce(
+      new Uint8Array([
+        0x44, 0xdd, 0xdb, 0x39, 0xbd, 0xb2, 0xaf, 0x80, 0xc1, 0x47, 0x89, 0x4c, 0x1d, 0x75, 0x6a, 0xda, 0x3d, 0x1c,
+        0x2a, 0xc2, 0xb1, 0x00, 0x54, 0x1e, 0x04, 0xfe, 0x87, 0xb4, 0xa5, 0x9e, 0x12, 0x43,
+      ]),
+    );
+    const response = api.blake2sToField({ data: input });
+    const result = Fr.fromBuffer(response.field);
+    expect(result).toEqual(expected);
+  });
+});