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

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

@@ -3,7 +3,6 @@ import { Grumpkin, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@a
 import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { CompleteAddress } from '../contract/complete_address.js';
 import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
@@ -51,7 +50,7 @@ export async function computeAddress(publicKeys: PublicKeys, partialAddress: Fr)
   // 2. addressPoint = (preaddress * G) + ivpk_m
   // 3. address = addressPoint.x
   const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
-  const address = await new Grumpkin().add(
+  const address = await Grumpkin.add(
     await derivePublicKeyFromSecretKey(new Fq(preaddress.toBigInt())),
     publicKeys.masterIncomingViewingPublicKey,
   );
@@ -82,8 +81,7 @@ export async function computeAddressSecret(preaddress: Fr, ivsk: Fq) {
 }
 
 export function derivePublicKeyFromSecretKey(secretKey: Fq) {
-  const curve = new Grumpkin();
-  return curve.mul(curve.generator(), secretKey);
+  return Grumpkin.mul(Grumpkin.generator, secretKey);
 }
 
 /**
@@ -121,21 +119,3 @@ export async function deriveKeys(secretKey: Fr) {
     publicKeys,
   };
 }
-
-// Returns shared tagging secret computed with Diffie-Hellman key exchange.
-export 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();
-  const curve = new Grumpkin();
-  // Given A (known complete address) -> B (external address) and h == preaddress
-  // Compute shared secret as S = (h_A + ivsk_A) * Addr_Point_B
-
-  // Beware! h_a + ivsk_a (also known as the address secret) can lead to an address point with a negative y-coordinate, since there's two possible candidates
-  // 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));
-}

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';

package/src/l1-contracts/slash_factory.ts

@@ -0,0 +1,177 @@
+import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
+import { maxBigint } from '@aztec/foundation/bigint';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
+
+import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from 'viem';
+
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import {
+  OffenseToBigInt,
+  type SlashPayload,
+  type ValidatorSlash,
+  type ValidatorSlashOffense,
+  bigIntToOffense,
+} from '../slashing/index.js';
+
+export class SlashFactoryContract {
+  private readonly logger = createLogger('contracts:slash_factory');
+  private readonly contract: GetContractReturnType<typeof SlashFactoryAbi, ViemClient>;
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    this.contract = getContract({
+      address: typeof address === 'string' ? address : address.toString(),
+      abi: SlashFactoryAbi,
+      client,
+    });
+  }
+
+  public get address() {
+    return EthAddress.fromString(this.contract.address);
+  }
+
+  public buildCreatePayloadRequest(slashes: ValidatorSlash[]): L1TxRequest {
+    const sorted = this.sortSlashes(slashes);
+
+    return {
+      to: this.contract.address,
+      data: encodeFunctionData({
+        abi: SlashFactoryAbi,
+        functionName: 'createSlashPayload',
+        args: [
+          sorted.map(d => d.validator.toString()),
+          sorted.map(d => d.amount),
+          sorted.map(d => d.offenses.map(packValidatorSlashOffense)),
+        ],
+      }),
+    };
+  }
+
+  /** Tries to extract a SlashPayloadCreated event from the given logs. */
+  public tryExtractSlashPayloadCreatedEvent(logs: Log[]) {
+    return tryExtractEvent(logs, this.address.toString(), SlashFactoryAbi, 'SlashPayloadCreated');
+  }
+
+  public async getSlashPayloadCreatedEvents(): Promise<SlashPayload[]> {
+    const events = await this.contract.getEvents.SlashPayloadCreated();
+    return Promise.all(
+      events.map(async event => {
+        const { validators, amounts, offenses } = event.args;
+        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
+          validator: EthAddress.fromString(validator),
+          amount: amounts![i],
+          offenses: offenses![i].map(unpackValidatorSlashOffense),
+        }));
+
+        const block = await this.client.getBlock({ blockNumber: event.blockNumber, includeTransactions: false });
+        return { address: EthAddress.fromString(event.args.payloadAddress!), slashes, timestamp: block.timestamp };
+      }),
+    );
+  }
+
+  /**
+   * Searches for a slash payload in the events emitted by the contract.
+   * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
+   * @param payloadAddress The address of the payload to search for.
+   * @param constants The L1 rollup constants needed for time calculations.
+   */
+  public async getSlashPayloadFromEvents(
+    payloadAddress: EthAddress,
+    settings: {
+      logsBatchSize?: number;
+      slashingRoundSize: number;
+      slashingPayloadLifetimeInRounds: number;
+    } & Pick<L1RollupConstants, 'slotDuration' | 'ethereumSlotDuration'>,
+  ): Promise<Omit<SlashPayload, 'votes'> | undefined> {
+    // We query for the log where the payload was emitted walking backwards until we go past payload expiration time
+    // Note that all log queries require a block range, and RPC providers cap the max range (eg quicknode is 10k blocks).
+    const { slashingRoundSize, slashingPayloadLifetimeInRounds, slotDuration, ethereumSlotDuration } = settings;
+    const currentBlockNumber = await this.client.getBlockNumber({ cacheTime: 0 });
+
+    // Why the +1 below? Just for good measure. Better err on the safe side.
+    const earliestBlockNumber = maxBigint(
+      0n,
+      currentBlockNumber -
+        ((BigInt(slashingPayloadLifetimeInRounds) + 1n) * BigInt(slashingRoundSize) * BigInt(slotDuration)) /
+          BigInt(ethereumSlotDuration),
+    );
+
+    this.logger.trace(
+      `Starting search for slash payload ${payloadAddress} from block ${currentBlockNumber} with earliest block ${earliestBlockNumber}`,
+    );
+    const batchSize = BigInt(settings.logsBatchSize ?? 10000);
+    let toBlock = currentBlockNumber;
+
+    do {
+      const fromBlock = maxBigint(earliestBlockNumber, toBlock - batchSize);
+      this.logger.trace(`Searching for slash payload ${payloadAddress} in blocks ${fromBlock} to ${toBlock}`);
+      const logs = await this.contract.getEvents.SlashPayloadCreated(
+        { payloadAddress: payloadAddress.toString() },
+        { fromBlock, toBlock, strict: true },
+      );
+
+      // We found the payload, return it
+      if (logs.length > 0) {
+        const log = logs[0];
+        const { validators, amounts, offenses } = log.args;
+
+        // Convert the data to our internal types
+        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
+          validator: EthAddress.fromString(validator),
+          amount: amounts![i],
+          offenses: offenses![i].map(unpackValidatorSlashOffense),
+        }));
+
+        // Get the timestamp from the block
+        const block = await this.client.getBlock({ blockNumber: log.blockNumber, includeTransactions: false });
+
+        return { address: payloadAddress, slashes, timestamp: block.timestamp };
+      }
+
+      // If not found, we go back one batch
+      toBlock -= batchSize;
+    } while (toBlock > earliestBlockNumber);
+
+    return undefined;
+  }
+
+  public async getAddressAndIsDeployed(
+    slashes: ValidatorSlash[],
+  ): Promise<{ address: EthAddress; salt: Hex; isDeployed: boolean }> {
+    const sortedSlashes = this.sortSlashes(slashes);
+    const [address, salt, isDeployed] = await this.contract.read.getAddressAndIsDeployed([
+      sortedSlashes.map(s => s.validator.toString()),
+      sortedSlashes.map(s => s.amount),
+      sortedSlashes.map(s => s.offenses.map(packValidatorSlashOffense)),
+    ]);
+    return { address: EthAddress.fromString(address), salt, isDeployed };
+  }
+
+  private sortSlashes(slashes: ValidatorSlash[]): ValidatorSlash[] {
+    const offenseSorter = (a: ValidatorSlashOffense, b: ValidatorSlashOffense) => {
+      return a.epochOrSlot === b.epochOrSlot ? a.offenseType - b.offenseType : Number(a.epochOrSlot - b.epochOrSlot);
+    };
+    return [...slashes]
+      .map(slash => ({ ...slash, offenses: [...slash.offenses].sort(offenseSorter) }))
+      .sort((a, b) => a.validator.toString().localeCompare(b.validator.toString()));
+  }
+}
+
+export function packValidatorSlashOffense(offense: ValidatorSlashOffense): bigint {
+  const offenseId = OffenseToBigInt[offense.offenseType];
+  if (offenseId > (1 << 8) - 1) {
+    throw new Error(`Offense type ${offense.offenseType} cannot be packed into 8 bits`);
+  }
+  return (offenseId << 120n) + offense.epochOrSlot;
+}
+
+export function unpackValidatorSlashOffense(packed: bigint): ValidatorSlashOffense {
+  const offenseId = (packed >> 120n) & 0xffn;
+  const epochOrSlot = packed & ((1n << 120n) - 1n);
+  const offenseType = bigIntToOffense(offenseId);
+  return { epochOrSlot, offenseType };
+}