@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/file-store/s3.ts

@@ -0,0 +1,250 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import {
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir, mkdtemp, stat, unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, dirname, join } from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { createGzip } from 'zlib';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+function normalizeBasePath(path: string): string {
+  return path?.replace(/^\/+|\/+$/g, '') ?? '';
+}
+
+export class S3FileStore implements FileStore {
+  private readonly s3: S3Client;
+  private readonly region: string;
+  private readonly endpoint?: string;
+  private readonly publicBaseUrl?: string;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    opts: { endpoint?: string; publicBaseUrl?: string },
+    private readonly log: Logger = createLogger('stdlib:s3-file-store'),
+  ) {
+    this.endpoint = opts.endpoint;
+    this.region = this.endpoint ? 'auto' : (process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1');
+    this.publicBaseUrl = opts.publicBaseUrl;
+
+    const clientOptions: any = {};
+    if (this.endpoint) {
+      clientOptions.region = 'auto';
+      clientOptions.endpoint = this.endpoint;
+      clientOptions.forcePathStyle = true;
+    } else {
+      clientOptions.region = this.region;
+    }
+    this.s3 = new S3Client(clientOptions);
+  }
+
+  public async save(path: string, data: Buffer, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(path);
+    const shouldCompress = !!opts.compress;
+
+    const body = shouldCompress ? (await import('zlib')).gzipSync(data) : data;
+    const contentLength = body.length;
+    const contentType = this.detectContentType(key, shouldCompress);
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+      ContentLength: contentLength,
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async upload(destPath: string, srcPath: string, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(destPath);
+    const shouldCompress = opts.compress !== false; // default true like GCS impl
+
+    await mkdir(dirname(srcPath), { recursive: true }).catch(() => undefined);
+    let contentLength: number | undefined;
+    let bodyPath = srcPath;
+
+    // We don't set Content-Encoding and we avoid SigV4 streaming (aws-chunked).
+    // With AWS SigV4 streaming uploads (Content-Encoding: aws-chunked[,gzip]), servers require
+    // x-amz-decoded-content-length (the size of the decoded payload) and an exact Content-Length
+    // that includes chunk metadata. For on-the-fly compression, providing
+    // those values without buffering or a pre-pass is impractical. Instead, we pre-gzip to a temp file
+    // to know ContentLength up-front and upload the gzipped bytes as-is, omitting Content-Encoding.
+    // Reference: AWS SigV4 streaming (chunked upload) requirements —
+    // https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html
+    if (shouldCompress) {
+      // Pre-gzip to a temp file so we know the exact length for R2/S3 headers
+      const tmpDir = await mkdtemp(join(tmpdir(), 's3-upload-'));
+      const gzPath = join(tmpDir, `${basename(srcPath)}.gz`);
+      try {
+        await pipeline(createReadStream(srcPath), createGzip(), createWriteStream(gzPath));
+        const st = await stat(gzPath);
+        contentLength = st.size;
+        bodyPath = gzPath;
+      } catch (err) {
+        // Ensure temp file is removed on failure
+        await unlink(gzPath).catch(() => undefined);
+        throw err;
+      }
+    } else {
+      const st = await stat(srcPath);
+      contentLength = st.size;
+      bodyPath = srcPath;
+    }
+
+    const bodyStream = createReadStream(bodyPath);
+    const contentType = this.detectContentType(key, shouldCompress);
+    try {
+      const put = new PutObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+        Body: bodyStream as any,
+        ContentType: contentType,
+        CacheControl: opts.metadata?.['Cache-control'],
+        Metadata: this.extractUserMetadata(opts.metadata),
+        // Explicitly set ContentLength so R2 can compute x-amz-decoded-content-length correctly
+        ContentLength: contentLength,
+      } as any);
+      await this.s3.send(put);
+    } finally {
+      if (shouldCompress && bodyPath !== srcPath) {
+        await unlink(bodyPath).catch(() => undefined);
+      }
+    }
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const stream = out.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    await mkdir(dirname(destPath), { recursive: true });
+    await pipeline(out.Body as Readable, createWriteStream(destPath));
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    try {
+      const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+      await this.s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err: any) {
+      const code = err?.$metadata?.httpStatusCode ?? err?.name ?? err?.Code;
+      if (code === 404 || code === 'NotFound' || code === 'NoSuchKey') {
+        return false;
+      }
+      this.log.warn(`Error checking existence for ${pathOrUrlStr}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+  }
+
+  private extractUserMetadata(meta?: Record<string, string>): Record<string, string> | undefined {
+    if (!meta) {
+      return undefined;
+    }
+    const { ['Cache-control']: _ignored, ...rest } = meta;
+    return Object.keys(rest).length ? rest : undefined;
+  }
+
+  private detectContentType(key: string, isCompressed: boolean | undefined): string | undefined {
+    // Basic content type inference
+    const lower = key.toLowerCase();
+    if (lower.endsWith('.json') || lower.endsWith('.json.gz')) {
+      return 'application/json';
+    }
+    if (lower.endsWith('.txt') || lower.endsWith('.log') || lower.endsWith('.csv') || lower.endsWith('.md')) {
+      return 'text/plain; charset=utf-8';
+    }
+    if (lower.endsWith('.db') || lower.endsWith('.sqlite') || lower.endsWith('.bin')) {
+      return 'application/octet-stream';
+    }
+    if (lower.endsWith('.wasm') || lower.endsWith('.wasm.gz')) {
+      return 'application/wasm';
+    }
+    // If compressed, prefer octet-stream unless known
+    if (isCompressed) {
+      return 'application/octet-stream';
+    }
+    return undefined;
+  }
+
+  private buildReturnedUrl(key: string, makePublic: boolean): string {
+    if (!makePublic) {
+      return `s3://${this.bucketName}/${key}`;
+    }
+
+    if (this.publicBaseUrl) {
+      const base = this.publicBaseUrl.replace(/\/$/, '');
+      // key already includes basePath via getFullPath, so do not prefix basePath again
+      const full = key.replace(/^\/+/, '');
+      return `${base}/${full}`;
+    }
+
+    // Try to synthesize a URL from endpoint if available (works for public R2 buckets)
+    if (this.endpoint) {
+      try {
+        const url = new URL(this.endpoint);
+        return `https://${this.bucketName}.${url.host}/${key}`;
+      } catch {
+        // fallthrough
+      }
+    }
+
+    // Fallback to AWS style URL if region looks valid
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  private getBucketAndKey(pathOrUrlStr: string): { bucket: string; key: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      if (url.protocol === 's3:') {
+        return { bucket: url.host, key: url.pathname.replace(/^\/+/, '') };
+      }
+      // For https URLs, try to infer virtual-hosted or path-style
+      if (url.protocol === 'https:' || url.protocol === 'http:') {
+        // If the URL matches the configured publicBaseUrl host, map back to our bucket and key
+        if (this.publicBaseUrl && url.host === new URL(this.publicBaseUrl).host) {
+          return { bucket: this.bucketName, key: url.pathname.replace(/^\/+/, '') };
+        }
+        const hostParts = url.host.split('.');
+        if (hostParts.length > 3 && (hostParts[1] === 's3' || hostParts[hostParts.length - 2] === 'r2')) {
+          // virtual hosted
+          return { bucket: hostParts[0], key: url.pathname.replace(/^\/+/, '') };
+        } else if (this.endpoint && url.host === new URL(this.endpoint).host) {
+          // path-style at custom endpoint
+          const [bucket, ...rest] = url.pathname.replace(/^\/+/, '').split('/');
+          return { bucket, key: rest.join('/') };
+        }
+      }
+    }
+    // Treat as path
+    return { bucket: this.bucketName, key: this.getFullPath(pathOrUrlStr) };
+  }
+
+  private getFullPath(path: string): string {
+    const base = normalizeBasePath(this.basePath);
+    const rel = path.replace(/^\/+/, '');
+    return base ? join(base, rel) : rel;
+  }
+}

package/src/gas/gas.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -14,7 +14,10 @@ export type GasDimensions = (typeof GasDimensions)[number];
 
 /** Gas amounts in each dimension. */
 export class Gas {
-  constructor(public readonly daGas: UInt32, public readonly l2Gas: UInt32) {}
+  constructor(
+    public readonly daGas: UInt32,
+    public readonly l2Gas: UInt32,
+  ) {}
 
   static get schema() {
     return z
@@ -25,6 +28,10 @@ export class Gas {
       .transform(Gas.from);
   }
 
+  getSize() {
+    return 4 /* daGas */ + 4 /* l2Gas */;
+  }
+
   clone(): Gas {
     return new Gas(this.daGas, this.l2Gas);
   }
@@ -41,6 +48,20 @@ export class Gas {
     return new Gas(fields.daGas ?? 0, fields.l2Gas ?? 0);
   }
 
+  /**
+   * Creates a Gas instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing Gas fields
+   * @returns A Gas instance
+   */
+  static fromPlainObject(obj: any): Gas {
+    if (obj instanceof Gas) {
+      return obj;
+    }
+    return Gas.from(obj);
+  }
+
   static empty() {
     return new Gas(0, 0);
   }
@@ -85,7 +106,7 @@ export class Gas {
 
   computeFee(gasFees: GasFees) {
     return GasDimensions.reduce(
-      (acc, dimension) => acc.add(gasFees.get(dimension).mul(new Fr(this.get(dimension)))),
+      (acc, dimension) => acc.add(new Fr(gasFees.get(dimension)).mul(new Fr(this.get(dimension)))),
       Fr.ZERO,
     );
   }

package/src/gas/gas_fees.ts

@@ -1,28 +1,35 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt128BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import type { UInt128 } from '../types/shared.js';
 import type { GasDimensions } from './gas.js';
 
 /** Gas prices for each dimension. */
 export class GasFees {
-  public readonly feePerDaGas: Fr;
-  public readonly feePerL2Gas: Fr;
+  public readonly feePerDaGas: UInt128;
+  public readonly feePerL2Gas: UInt128;
 
-  constructor(feePerDaGas: Fr | number | bigint, feePerL2Gas: Fr | number | bigint) {
-    this.feePerDaGas = new Fr(feePerDaGas);
-    this.feePerL2Gas = new Fr(feePerL2Gas);
+  constructor(feePerDaGas: number | bigint, feePerL2Gas: number | bigint) {
+    this.feePerDaGas = BigInt(feePerDaGas);
+    this.feePerL2Gas = BigInt(feePerL2Gas);
   }
 
   static get schema() {
     return z
       .object({
-        feePerDaGas: schemas.Fr,
-        feePerL2Gas: schemas.Fr,
+        feePerDaGas: schemas.BigInt,
+        feePerL2Gas: schemas.BigInt,
       })
       .transform(GasFees.from);
   }
@@ -32,7 +39,7 @@ export class GasFees {
   }
 
   equals(other: GasFees) {
-    return this.feePerDaGas.equals(other.feePerDaGas) && this.feePerL2Gas.equals(other.feePerL2Gas);
+    return this.feePerDaGas === other.feePerDaGas && this.feePerL2Gas === other.feePerL2Gas;
   }
 
   get(dimension: GasDimensions) {
@@ -48,12 +55,9 @@ export class GasFees {
     if (scalar === 1 || scalar === 1n) {
       return this.clone();
     } else if (typeof scalar === 'bigint') {
-      return new GasFees(new Fr(this.feePerDaGas.toBigInt() * scalar), new Fr(this.feePerL2Gas.toBigInt() * scalar));
+      return new GasFees(this.feePerDaGas * scalar, this.feePerL2Gas * scalar);
     } else {
-      return new GasFees(
-        new Fr(this.feePerDaGas.toNumberUnsafe() * scalar),
-        new Fr(this.feePerL2Gas.toNumberUnsafe() * scalar),
-      );
+      return new GasFees(Number(this.feePerDaGas) * scalar, Number(this.feePerL2Gas) * scalar);
     }
   }
 
@@ -61,30 +65,44 @@ export class GasFees {
     return new GasFees(fields.feePerDaGas, fields.feePerL2Gas);
   }
 
+  /**
+   * Creates a GasFees instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing GasFees fields
+   * @returns A GasFees instance
+   */
+  static fromPlainObject(obj: any): GasFees {
+    if (obj instanceof GasFees) {
+      return obj;
+    }
+    return GasFees.from(obj);
+  }
+
   static random() {
-    return new GasFees(Fr.random(), Fr.random());
+    return new GasFees(Math.floor(Math.random() * 1e9), Math.floor(Math.random() * 1e9));
   }
 
   static empty() {
-    return new GasFees(Fr.ZERO, Fr.ZERO);
+    return new GasFees(0, 0);
   }
 
   isEmpty() {
-    return this.feePerDaGas.isZero() && this.feePerL2Gas.isZero();
+    return this.feePerDaGas === 0n && this.feePerL2Gas === 0n;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): GasFees {
     const reader = BufferReader.asReader(buffer);
-    return new GasFees(reader.readObject(Fr), reader.readObject(Fr));
+    return new GasFees(reader.readUInt128(), reader.readUInt128());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.feePerDaGas, this.feePerL2Gas);
+    return serializeToBuffer(bigintToUInt128BE(this.feePerDaGas), bigintToUInt128BE(this.feePerL2Gas));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new GasFees(reader.readField(), reader.readField());
+    return new GasFees(reader.readField().toBigInt(), reader.readField().toBigInt());
   }
 
   toFields() {
@@ -93,12 +111,12 @@ export class GasFees {
 
   toInspect() {
     return {
-      feePerDaGas: this.feePerDaGas.toNumberUnsafe(),
-      feePerL2Gas: this.feePerL2Gas.toNumberUnsafe(),
+      feePerDaGas: this.feePerDaGas,
+      feePerL2Gas: this.feePerL2Gas,
     };
   }
 
   [inspect.custom]() {
-    return `GasFees { feePerDaGas=${this.feePerDaGas.toBigInt()} feePerL2Gas=${this.feePerL2Gas.toBigInt()} }`;
+    return `GasFees { feePerDaGas=${this.feePerDaGas} feePerL2Gas=${this.feePerL2Gas} }`;
   }
 }

package/src/gas/gas_settings.ts

@@ -1,5 +1,11 @@
-import { DEFAULT_GAS_LIMIT, DEFAULT_TEARDOWN_GAS_LIMIT, GAS_SETTINGS_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import {
+  DEFAULT_DA_GAS_LIMIT,
+  DEFAULT_L2_GAS_LIMIT,
+  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
+  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  GAS_SETTINGS_LENGTH,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -48,6 +54,25 @@ export class GasSettings {
     );
   }
 
+  /**
+   * Creates a GasSettings instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing GasSettings fields
+   * @returns A GasSettings instance
+   */
+  static fromPlainObject(obj: any): GasSettings {
+    if (obj instanceof GasSettings) {
+      return obj;
+    }
+    return new GasSettings(
+      Gas.fromPlainObject(obj.gasLimits),
+      Gas.fromPlainObject(obj.teardownGasLimits),
+      GasFees.fromPlainObject(obj.maxFeesPerGas),
+      GasFees.fromPlainObject(obj.maxPriorityFeesPerGas),
+    );
+  }
+
   clone() {
     return new GasSettings(
       this.gasLimits.clone(),
@@ -60,11 +85,7 @@ export class GasSettings {
   /** Returns the maximum fee to be paid according to gas limits and max fees set. */
   getFeeLimit() {
     return GasDimensions.reduce(
-      (acc, dimension) =>
-        this.maxFeesPerGas
-          .get(dimension)
-          .mul(new Fr(this.gasLimits.get(dimension)))
-          .add(acc),
+      (acc, dimension) => new Fr(this.maxFeesPerGas.get(dimension)).mul(new Fr(this.gasLimits.get(dimension))).add(acc),
       Fr.ZERO,
     );
   }
@@ -82,10 +103,10 @@ export class GasSettings {
     maxPriorityFeesPerGas?: GasFees;
   }) {
     return GasSettings.from({
-      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_GAS_LIMIT, daGas: DEFAULT_GAS_LIMIT },
+      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_L2_GAS_LIMIT, daGas: DEFAULT_DA_GAS_LIMIT },
       teardownGasLimits: overrides.teardownGasLimits ?? {
-        l2Gas: DEFAULT_TEARDOWN_GAS_LIMIT,
-        daGas: DEFAULT_TEARDOWN_GAS_LIMIT,
+        l2Gas: DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+        daGas: DEFAULT_TEARDOWN_DA_GAS_LIMIT,
       },
       maxFeesPerGas: overrides.maxFeesPerGas,
       maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty(),

package/src/gas/gas_used.ts

@@ -1,4 +1,4 @@
-import type { Gas } from './gas.js';
+import { Gas } from './gas.js';
 
 export interface GasUsed {
   /**
@@ -21,3 +21,24 @@ export interface GasUsed {
    */
   billedGas: Gas;
 }
+
+/**
+ * Creates a GasUsed from a plain object without Zod validation.
+ * This method is optimized for performance and skips validation, making it suitable
+ * for deserializing trusted data (e.g., from C++ via MessagePack).
+ * @param obj - Plain object containing GasUsed fields
+ * @returns A GasUsed object
+ */
+export function gasUsedFromPlainObject(obj: any): GasUsed {
+  return {
+    totalGas: Gas.fromPlainObject(obj.totalGas),
+    publicGas: Gas.fromPlainObject(obj.publicGas),
+    teardownGas: Gas.fromPlainObject(obj.teardownGas),
+    billedGas: Gas.fromPlainObject(obj.billedGas),
+  };
+}
+
+// Export as a namespace to match the pattern
+export const GasUsed = {
+  fromPlainObject: gasUsedFromPlainObject,
+};

package/src/hash/hash.ts

@@ -1,17 +1,19 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2Hash, poseidon2HashWithSeparator, sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { GeneratorIndex, NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { AztecAddress } from '../aztec-address/index.js';
-import type { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { AztecAddress } from '../aztec-address/index.js';
 
 /**
  * Computes a hash of a given verification key.
- * @param vkBuf - The verification key as fields.
+ * @param keyAsFields - The verification key as fields.
  * @returns The hash of the verification key.
  */
-export function hashVK(keyAsFields: Fr[]): Promise<Fr> {
-  return poseidon2Hash(keyAsFields);
+export async function hashVK(keyAsFields: Fr[]): Promise<Fr> {
+  // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
+  return await poseidon2Hash(keyAsFields);
 }
 
 /**
@@ -37,13 +39,12 @@ export function siloNoteHash(contract: AztecAddress, noteHash: Fr): Promise<Fr>
 
 /**
  * Computes a unique note hash.
- * @dev Includes a nonce which contains data that guarantees the resulting note hash will be unique.
- * @param nonce - A nonce (typically derived from tx hash and note hash index in the tx).
+ * @param noteNonce - The nonce that was injected into the note hash preimage in order to guarantee uniqueness.
  * @param siloedNoteHash - A siloed note hash.
  * @returns A unique note hash.
  */
-export function computeUniqueNoteHash(nonce: Fr, siloedNoteHash: Fr): Promise<Fr> {
-  return poseidon2HashWithSeparator([nonce, siloedNoteHash], GeneratorIndex.UNIQUE_NOTE_HASH);
+export function computeUniqueNoteHash(noteNonce: Fr, siloedNoteHash: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([noteNonce, siloedNoteHash], GeneratorIndex.UNIQUE_NOTE_HASH);
 }
 
 /**
@@ -57,6 +58,17 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
   return poseidon2HashWithSeparator([contract, innerNullifier], GeneratorIndex.OUTER_NULLIFIER);
 }
 
+/**
+ * Computes the protocol nullifier, which is the hash of the initial tx request siloed with the null msg sender address.
+ * @param txRequestHash - The hash of the initial tx request.
+ * @returns The siloed value of the protocol nullifier.
+ *
+ * @dev Must match the implementation in noir-protocol-circuits/crates/types/src/hash.nr > compute_protocol_nullifier
+ */
+export function computeProtocolNullifier(txRequestHash: Fr): Promise<Fr> {
+  return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
+}
+
 /**
  * Computes a public data tree value ready for insertion.
  * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
@@ -80,8 +92,9 @@ export function computePublicDataTreeLeafSlot(contractAddress: AztecAddress, sto
 
 /**
  * Computes the hash of a list of arguments.
+ * Used for input arguments or return values for private functions, or for authwit creation.
  * @param args - Arguments to hash.
- * @returns Pedersen hash of the arguments.
+ * @returns Hash of the arguments.
  */
 export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   if (args.length === 0) {
@@ -91,6 +104,15 @@ export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
 }
 
+/**
+ * Computes the hash of a public function's calldata.
+ * @param calldata - Calldata to hash.
+ * @returns Hash of the calldata.
+ */
+export function computeCalldataHash(calldata: Fr[]): Promise<Fr> {
+  return poseidon2HashWithSeparator(calldata, GeneratorIndex.PUBLIC_CALLDATA);
+}
+
 /**
  * Computes a hash of a secret.
  * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.
@@ -113,21 +135,18 @@ export async function computeL1ToL2MessageNullifier(contract: AztecAddress, mess
  * Calculates a siloed hash of a scoped l2 to l1 message.
  * @returns Fr containing 248 bits of information of sha256 hash.
  */
-export function siloL2ToL1Message(l2ToL1Message: ScopedL2ToL1Message, version: Fr, chainId: Fr): Fr {
-  if (l2ToL1Message.contractAddress.isZero()) {
-    return Fr.ZERO;
-  }
-  // Left-pad recipient to 32 bytes to match what the circuit is doing
-  // TODO: Only hash 20 bytes for l2l1 recipient everywhere.
-  const paddedRecipient = Buffer.alloc(32);
-  l2ToL1Message.message.recipient.toBuffer().copy(paddedRecipient, 12);
-
-  const preimage = Buffer.concat([
-    l2ToL1Message.contractAddress.toBuffer(),
-    version.toBuffer(),
-    paddedRecipient,
-    chainId.toBuffer(),
-    l2ToL1Message.message.content.toBuffer(),
-  ]);
-  return Fr.fromBuffer(sha256Trunc(preimage));
+export function computeL2ToL1MessageHash({
+  l2Sender,
+  l1Recipient,
+  content,
+  rollupVersion,
+  chainId,
+}: {
+  l2Sender: AztecAddress;
+  l1Recipient: EthAddress;
+  content: Fr;
+  rollupVersion: Fr;
+  chainId: Fr;
+}) {
+  return sha256ToField([l2Sender, rollupVersion, l1Recipient, chainId, content]);
 }

package/src/hash/map_slot.ts

@@ -1,5 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * Computes the resulting storage slot for an entry in a map.