@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/kernel/private_to_public_kernel_circuit_public_inputs.ts

@@ -1,49 +1,49 @@
 import { GeneratorIndex, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas } from '../gas/gas.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
+import type { UInt64 } from '../types/index.js';
 import { PrivateToPublicAccumulatedData } from './private_to_public_accumulated_data.js';
 import { PublicCallRequest } from './public_call_request.js';
 
 export class PrivateToPublicKernelCircuitPublicInputs {
   constructor(
     public constants: TxConstantData,
-    public rollupValidationRequests: RollupValidationRequests,
     public nonRevertibleAccumulatedData: PrivateToPublicAccumulatedData,
     public revertibleAccumulatedData: PrivateToPublicAccumulatedData,
     public publicTeardownCallRequest: PublicCallRequest,
     public gasUsed: Gas,
     public feePayer: AztecAddress,
+    public includeByTimestamp: UInt64,
   ) {}
 
   toBuffer() {
     return serializeToBuffer(
       this.constants,
-      this.rollupValidationRequests,
       this.nonRevertibleAccumulatedData,
       this.revertibleAccumulatedData,
       this.publicTeardownCallRequest,
       this.gasUsed,
       this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
     );
   }
 
   static getFields(fields: FieldsOf<PrivateToPublicKernelCircuitPublicInputs>) {
     return [
       fields.constants,
-      fields.rollupValidationRequests,
       fields.nonRevertibleAccumulatedData,
       fields.revertibleAccumulatedData,
       fields.publicTeardownCallRequest,
       fields.gasUsed,
       fields.feePayer,
+      fields.includeByTimestamp,
     ] as const;
   }
 
@@ -51,24 +51,24 @@ export class PrivateToPublicKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToPublicKernelCircuitPublicInputs(
       reader.readObject(TxConstantData),
-      reader.readObject(RollupValidationRequests),
       reader.readObject(PrivateToPublicAccumulatedData),
       reader.readObject(PrivateToPublicAccumulatedData),
       reader.readObject(PublicCallRequest),
       reader.readObject(Gas),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
     );
   }
 
   static empty() {
     return new PrivateToPublicKernelCircuitPublicInputs(
       TxConstantData.empty(),
-      RollupValidationRequests.empty(),
       PrivateToPublicAccumulatedData.empty(),
       PrivateToPublicAccumulatedData.empty(),
       PublicCallRequest.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
+      0n,
     );
   }
 

package/src/kernel/private_to_rollup_kernel_circuit_public_inputs.ts

@@ -2,14 +2,14 @@ import { GeneratorIndex, PRIVATE_TO_ROLLUP_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH }
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas } from '../gas/gas.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
+import type { UInt64 } from '../types/index.js';
 import { PrivateToRollupAccumulatedData } from './private_to_rollup_accumulated_data.js';
 
 /**
@@ -22,10 +22,6 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * Data which is not modified by the circuits.
      */
     public constants: TxConstantData,
-    /**
-     * Validation requests accumulated from private and public execution to be completed by the rollup.
-     */
-    public rollupValidationRequests: RollupValidationRequests,
     /**
      * Data accumulated from both public and private circuits.
      */
@@ -38,6 +34,10 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * The address of the fee payer for the transaction.
      */
     public feePayer: AztecAddress,
+    /**
+     * The timestamp by which the transaction must be included in a block.
+     */
+    public includeByTimestamp: UInt64,
   ) {}
 
   getNonEmptyNullifiers() {
@@ -45,7 +45,13 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.constants, this.rollupValidationRequests, this.end, this.gasUsed, this.feePayer);
+    return serializeToBuffer(
+      this.constants,
+      this.end,
+      this.gasUsed,
+      this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
+    );
   }
 
   /**
@@ -57,20 +63,20 @@ export class PrivateToRollupKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToRollupKernelCircuitPublicInputs(
       reader.readObject(TxConstantData),
-      reader.readObject(RollupValidationRequests),
       reader.readObject(PrivateToRollupAccumulatedData),
       reader.readObject(Gas),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
     );
   }
 
   static empty() {
     return new PrivateToRollupKernelCircuitPublicInputs(
       TxConstantData.empty(),
-      RollupValidationRequests.empty(),
       PrivateToRollupAccumulatedData.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
+      0n,
     );
   }
 
@@ -88,7 +94,7 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   static getFields(fields: FieldsOf<PrivateToRollupKernelCircuitPublicInputs>) {
-    return [fields.constants, fields.rollupValidationRequests, fields.end, fields.gasUsed, fields.feePayer] as const;
+    return [fields.constants, fields.end, fields.gasUsed, fields.feePayer, fields.includeByTimestamp] as const;
   }
 
   /** Creates an instance from a hex string. */

package/src/kernel/private_validation_requests.ts

@@ -3,17 +3,14 @@ import {
   MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
 import { ScopedKeyValidationRequestAndGenerator } from '../kernel/hints/scoped_key_validation_request_and_generator.js';
+import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedReadRequest } from './hints/read_request.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
 import { OptionalNumber } from './utils/optional_number.js';
 
 /**
@@ -21,23 +18,18 @@ import { OptionalNumber } from './utils/optional_number.js';
  */
 export class PrivateValidationRequests {
   constructor(
-    /**
-     * Validation requests that cannot be fulfilled in the current context (private or public), and must be instead be
-     * forwarded to the rollup for it to take care of them.
-     */
-    public forRollup: RollupValidationRequests,
     /**
      * All the read requests made in this transaction.
      */
-    public noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+    public noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
     /**
      * All the nullifier read requests made in this transaction.
      */
-    public nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    public nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     /**
      * All the key validation requests made in this transaction.
      */
-    public scopedKeyValidationRequestsAndGenerators: Tuple<
+    public scopedKeyValidationRequestsAndGenerators: ClaimedLengthArray<
       ScopedKeyValidationRequestAndGenerator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
     >,
@@ -51,17 +43,15 @@ export class PrivateValidationRequests {
 
   getSize() {
     return (
-      this.forRollup.getSize() +
-      arraySerializedSizeOfNonEmpty(this.noteHashReadRequests) +
-      arraySerializedSizeOfNonEmpty(this.nullifierReadRequests) +
-      arraySerializedSizeOfNonEmpty(this.scopedKeyValidationRequestsAndGenerators) +
+      this.noteHashReadRequests.getSize() +
+      this.nullifierReadRequests.getSize() +
+      this.scopedKeyValidationRequestsAndGenerators.getSize() +
       this.splitCounter.getSize()
     );
   }
 
   toBuffer() {
     return serializeToBuffer(
-      this.forRollup,
       this.noteHashReadRequests,
       this.nullifierReadRequests,
       this.scopedKeyValidationRequestsAndGenerators,
@@ -73,17 +63,6 @@ export class PrivateValidationRequests {
     return bufferToHex(this.toBuffer());
   }
 
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new PrivateValidationRequests(
-      reader.readObject(RollupValidationRequests),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
-      reader.readObject(OptionalNumber),
-    );
-  }
-
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer or reader to read from.
@@ -92,10 +71,11 @@ export class PrivateValidationRequests {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PrivateValidationRequests(
-      reader.readObject(RollupValidationRequests),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX)),
+      reader.readObject(
+        ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+      ),
       reader.readObject(OptionalNumber),
     );
   }
@@ -111,30 +91,19 @@ export class PrivateValidationRequests {
 
   static empty() {
     return new PrivateValidationRequests(
-      RollupValidationRequests.empty(),
-      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
-      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
-      makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator.empty),
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX),
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX),
+      ClaimedLengthArray.empty(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
       OptionalNumber.empty(),
     );
   }
 
   [inspect.custom]() {
     return `PrivateValidationRequests {
-  forRollup: ${inspect(this.forRollup)},
-  noteHashReadRequests: [${this.noteHashReadRequests
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
-  nullifierReadRequests: [${this.nullifierReadRequests
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
-  scopedKeyValidationRequestsAndGenerators: [${this.scopedKeyValidationRequestsAndGenerators
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
-  splitCounter: ${this.splitCounter}
+  noteHashReadRequests: ${inspect(this.noteHashReadRequests)},
+  nullifierReadRequests: ${inspect(this.nullifierReadRequests)},
+  scopedKeyValidationRequestsAndGenerators: ${inspect(this.scopedKeyValidationRequestsAndGenerators)},
+  splitCounter: ${this.splitCounter.getSize()}
   `;
   }
 }

package/src/kernel/public_call_request.ts

@@ -7,8 +7,8 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { inspect } from 'util';
 import { z } from 'zod';
 
-import { FunctionSelector } from '../abi/index.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { computeCalldataHash } from '../hash/index.js';
 import type { UInt32 } from '../types/shared.js';
 
 /**
@@ -24,15 +24,14 @@ export class PublicCallRequest {
      * The contract address being called.
      */
     public contractAddress: AztecAddress,
-    /**
-     * Function selector of the function being called.
-     */
-    public functionSelector: FunctionSelector,
     /**
      * Determines whether the call is modifying state.
      */
     public isStaticCall: boolean,
-    public argsHash: Fr,
+    /**
+     * Hash of the calldata of the function being called.
+     */
+    public calldataHash: Fr,
   ) {}
 
   static get schema() {
@@ -40,12 +39,11 @@ export class PublicCallRequest {
       .object({
         msgSender: AztecAddress.schema,
         contractAddress: AztecAddress.schema,
-        functionSelector: FunctionSelector.schema,
         isStaticCall: z.boolean(),
-        argsHash: schemas.Fr,
+        calldataHash: schemas.Fr,
       })
-      .transform(({ msgSender, contractAddress, functionSelector, isStaticCall, argsHash }) => {
-        return new PublicCallRequest(msgSender, contractAddress, functionSelector, isStaticCall, argsHash);
+      .transform(({ msgSender, contractAddress, isStaticCall, calldataHash }) => {
+        return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
       });
   }
 
@@ -58,13 +56,7 @@ export class PublicCallRequest {
   }
 
   static getFields(fields: FieldsOf<PublicCallRequest>) {
-    return [
-      fields.msgSender,
-      fields.contractAddress,
-      fields.functionSelector,
-      fields.isStaticCall,
-      fields.argsHash,
-    ] as const;
+    return [fields.msgSender, fields.contractAddress, fields.isStaticCall, fields.calldataHash] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): PublicCallRequest {
@@ -72,7 +64,6 @@ export class PublicCallRequest {
     return new PublicCallRequest(
       reader.readObject(AztecAddress),
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionSelector),
       reader.readBoolean(),
       reader.readField(),
     );
@@ -93,7 +84,6 @@ export class PublicCallRequest {
     return new PublicCallRequest(
       reader.readObject(AztecAddress),
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionSelector),
       reader.readBoolean(),
       reader.readObject(Fr),
     );
@@ -104,16 +94,12 @@ export class PublicCallRequest {
   }
 
   static empty() {
-    return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, FunctionSelector.empty(), false, Fr.ZERO);
+    return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, false, Fr.ZERO);
   }
 
   isEmpty(): boolean {
     return (
-      this.msgSender.isZero() &&
-      this.contractAddress.isZero() &&
-      this.functionSelector.isEmpty() &&
-      !this.isStaticCall &&
-      this.argsHash.isEmpty()
+      this.msgSender.isZero() && this.contractAddress.isZero() && !this.isStaticCall && this.calldataHash.isEmpty()
     );
   }
 
@@ -121,15 +107,93 @@ export class PublicCallRequest {
     return `PublicCallRequest {
       msgSender: ${this.msgSender}
       contractAddress: ${this.contractAddress}
-      functionSelector: ${this.functionSelector}
       isStaticCall: ${this.isStaticCall}
-      argsHash: ${this.argsHash}
+      calldataHash: ${this.calldataHash}
+    }`;
+  }
+
+  static async fromCalldata(
+    msgSender: AztecAddress,
+    contractAddress: AztecAddress,
+    isStaticCall: boolean,
+    calldata: Fr[],
+  ) {
+    const calldataHash = await computeCalldataHash(calldata);
+    return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
+  }
+}
+
+/**
+ * Represents lengths of arrays of public call requests.
+ */
+export class PublicCallRequestArrayLengths {
+  constructor(
+    /**
+     * Number of setup call requests
+     */
+    public setupCalls: number,
+    /**
+     * Number of app logic call requests
+     */
+    public appLogicCalls: number,
+    /**
+     * Whether there is a teardown call request
+     */
+    public teardownCall: boolean,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        setupCalls: z.number(),
+        appLogicCalls: z.number(),
+        teardownCall: z.boolean(),
+      })
+      .transform(({ setupCalls, appLogicCalls, teardownCall }) => {
+        return new PublicCallRequestArrayLengths(setupCalls, appLogicCalls, teardownCall);
+      });
+  }
+
+  static getFields(fields: FieldsOf<PublicCallRequestArrayLengths>) {
+    return [fields.setupCalls, fields.appLogicCalls, fields.teardownCall] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PublicCallRequestArrayLengths {
+    const reader = FieldReader.asReader(fields);
+    return new PublicCallRequestArrayLengths(reader.readU32(), reader.readU32(), reader.readBoolean());
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicCallRequestArrayLengths.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicCallRequestArrayLengths(reader.readNumber(), reader.readNumber(), reader.readBoolean());
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicCallRequestArrayLengths.getFields(this));
+  }
+
+  static empty() {
+    return new PublicCallRequestArrayLengths(0, 0, false);
+  }
+
+  [inspect.custom]() {
+    return `PublicCallRequestArrayLengths {
+      setupCalls: ${this.setupCalls}
+      appLogicCalls: ${this.appLogicCalls}
+      teardownCall: ${this.teardownCall}
     }`;
   }
 }
 
 export class CountedPublicCallRequest {
-  constructor(public inner: PublicCallRequest, public counter: UInt32) {}
+  constructor(
+    public inner: PublicCallRequest,
+    public counter: UInt32,
+  ) {}
 
   getSize() {
     return this.isEmpty() ? 0 : this.toBuffer().length;

package/src/kernel/utils/order_and_comparison.ts

@@ -17,23 +17,6 @@ export function countAccumulatedItems<T extends IsEmpty>(arr: T[]) {
   }, 0);
 }
 
-// Merges two arrays of length N into an array of length N.
-export function mergeAccumulatedData<T extends IsEmpty, N extends number>(
-  arr0: Tuple<T, N>,
-  arr1: Tuple<T, N>,
-  length: N = arr0.length as N, // Need this for ts to infer the return Tuple length.
-): Tuple<T, N> {
-  const numNonEmptyItems0 = countAccumulatedItems(arr0);
-  const numNonEmptyItems1 = countAccumulatedItems(arr1);
-  if (numNonEmptyItems0 + numNonEmptyItems1 > length) {
-    throw new Error('Combined non-empty items exceeded the maximum allowed.');
-  }
-
-  const arr = [...arr0] as Tuple<T, N>;
-  arr1.slice(0, numNonEmptyItems1).forEach((item, i) => (arr[i + numNonEmptyItems0] = item));
-  return arr;
-}
-
 // Sort items by a provided compare function. All empty items are padded to the right.
 function genericSort<T extends IsEmpty, N extends number>(
   arr: Tuple<T, N>,
@@ -61,11 +44,3 @@ export function sortByCounter<T extends Ordered & IsEmpty, N extends number>(
 ): Tuple<T, N> {
   return genericSort(arr, compareByCounter, ascending);
 }
-
-export function isEmptyArray<T extends IsEmpty>(arr: T[]): boolean {
-  return arr.every(item => item.isEmpty());
-}
-
-export function getNonEmptyItems<T extends IsEmpty>(arr: T[]): T[] {
-  return arr.filter(item => !item.isEmpty());
-}

package/src/keys/derivation.ts

@@ -1,5 +1,5 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { Grumpkin, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
+import { Grumpkin, poseidon2Hash, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
 import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
 
 import { AztecAddress } from '../aztec-address/index.js';
@@ -123,11 +123,7 @@ export async function deriveKeys(secretKey: Fr) {
 }
 
 // Returns shared tagging secret computed with Diffie-Hellman key exchange.
-export async function computeTaggingSecretPoint(
-  knownAddress: CompleteAddress,
-  ivsk: Fq,
-  externalAddress: AztecAddress,
-) {
+async function computeTaggingSecretPoint(knownAddress: CompleteAddress, ivsk: Fq, externalAddress: AztecAddress) {
   const knownPreaddress = await computePreaddress(await knownAddress.publicKeys.hash(), knownAddress.partialAddress);
   // TODO: #8970 - Computation of address point from x coordinate might fail
   const externalAddressPoint = await externalAddress.toAddressPoint();
@@ -139,3 +135,13 @@ export async function computeTaggingSecretPoint(
   // computeAddressSecret takes care of selecting the one that leads to a positive y-coordinate, which is the only valid address point
   return curve.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, ivsk));
 }
+
+export async function computeAppTaggingSecret(
+  knownAddress: CompleteAddress,
+  ivsk: Fq,
+  externalAddress: AztecAddress,
+  app: AztecAddress,
+) {
+  const taggingSecretPoint = await computeTaggingSecretPoint(knownAddress, ivsk, externalAddress);
+  return poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
+}

package/src/keys/public_keys.ts

@@ -143,7 +143,7 @@ export class PublicKeys {
 
   toNoirStruct() {
     // We need to use lowercase identifiers as those are what the noir interface expects
-    // eslint-disable-next-line camelcase
+
     return {
       // TODO(#6337): Directly dump account.publicKeys here
       /* eslint-disable camelcase */

package/src/l1-contracts/index.ts

@@ -0,0 +1 @@
+export * from './slash_factory.js';