@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/gas/gas_settings.ts

@@ -0,0 +1,150 @@
+import { DEFAULT_GAS_LIMIT, DEFAULT_TEARDOWN_GAS_LIMIT, GAS_SETTINGS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { Gas, GasDimensions } from './gas.js';
+import { GasFees } from './gas_fees.js';
+
+// docs:start:gas_settings_vars
+/** Gas usage and fees limits set by the transaction sender for different dimensions and phases. */
+export class GasSettings {
+  constructor(
+    public readonly gasLimits: Gas,
+    public readonly teardownGasLimits: Gas,
+    public readonly maxFeesPerGas: GasFees,
+    public readonly maxPriorityFeesPerGas: GasFees,
+  ) {}
+  // docs:end:gas_settings_vars
+
+  static get schema() {
+    return z
+      .object({
+        gasLimits: Gas.schema,
+        teardownGasLimits: Gas.schema,
+        maxFeesPerGas: GasFees.schema,
+        maxPriorityFeesPerGas: GasFees.schema,
+      })
+      .transform(GasSettings.from);
+  }
+
+  getSize(): number {
+    return this.toBuffer().length;
+  }
+
+  static from(args: {
+    gasLimits: FieldsOf<Gas>;
+    teardownGasLimits: FieldsOf<Gas>;
+    maxFeesPerGas: FieldsOf<GasFees>;
+    maxPriorityFeesPerGas: FieldsOf<GasFees>;
+  }) {
+    return new GasSettings(
+      Gas.from(args.gasLimits),
+      Gas.from(args.teardownGasLimits),
+      GasFees.from(args.maxFeesPerGas),
+      GasFees.from(args.maxPriorityFeesPerGas),
+    );
+  }
+
+  clone() {
+    return new GasSettings(
+      this.gasLimits.clone(),
+      this.teardownGasLimits.clone(),
+      this.maxFeesPerGas.clone(),
+      this.maxPriorityFeesPerGas.clone(),
+    );
+  }
+
+  /** 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),
+      Fr.ZERO,
+    );
+  }
+
+  /** Zero-value gas settings. */
+  static empty() {
+    return new GasSettings(Gas.empty(), Gas.empty(), GasFees.empty(), GasFees.empty());
+  }
+
+  /** Default gas settings to use when user has not provided them. Requires explicit max fees per gas. */
+  static default(overrides: {
+    gasLimits?: Gas;
+    teardownGasLimits?: Gas;
+    maxFeesPerGas: GasFees;
+    maxPriorityFeesPerGas?: GasFees;
+  }) {
+    return GasSettings.from({
+      gasLimits: overrides.gasLimits ?? { l2Gas: DEFAULT_GAS_LIMIT, daGas: DEFAULT_GAS_LIMIT },
+      teardownGasLimits: overrides.teardownGasLimits ?? {
+        l2Gas: DEFAULT_TEARDOWN_GAS_LIMIT,
+        daGas: DEFAULT_TEARDOWN_GAS_LIMIT,
+      },
+      maxFeesPerGas: overrides.maxFeesPerGas,
+      maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty(),
+    });
+  }
+
+  isEmpty() {
+    return (
+      this.gasLimits.isEmpty() &&
+      this.teardownGasLimits.isEmpty() &&
+      this.maxFeesPerGas.isEmpty() &&
+      this.maxPriorityFeesPerGas.isEmpty()
+    );
+  }
+
+  equals(other: GasSettings) {
+    return (
+      this.gasLimits.equals(other.gasLimits) &&
+      this.teardownGasLimits.equals(other.teardownGasLimits) &&
+      this.maxFeesPerGas.equals(other.maxFeesPerGas) &&
+      this.maxPriorityFeesPerGas.equals(other.maxPriorityFeesPerGas)
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): GasSettings {
+    const reader = BufferReader.asReader(buffer);
+    return new GasSettings(
+      reader.readObject(Gas),
+      reader.readObject(Gas),
+      reader.readObject(GasFees),
+      reader.readObject(GasFees),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...GasSettings.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): GasSettings {
+    const reader = FieldReader.asReader(fields);
+    return new GasSettings(
+      reader.readObject(Gas),
+      reader.readObject(Gas),
+      reader.readObject(GasFees),
+      reader.readObject(GasFees),
+    );
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...GasSettings.getFields(this));
+    if (fields.length !== GAS_SETTINGS_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for GasSettings. Expected ${GAS_SETTINGS_LENGTH} but got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static getFields(fields: FieldsOf<GasSettings>) {
+    return [fields.gasLimits, fields.teardownGasLimits, fields.maxFeesPerGas, fields.maxPriorityFeesPerGas] as const;
+  }
+}

package/src/gas/gas_used.ts

@@ -0,0 +1,23 @@
+import type { Gas } from './gas.js';
+
+export interface GasUsed {
+  /**
+   * Total gas used across both private and public executions.
+   * Note that this does not determine the transaction fee. The fee is calculated with billedGas, which uses `teardownGasLimits` from
+   * `GasSettings`, rather than actual teardown gas.
+   */
+  totalGas: Gas;
+
+  /** Total gas used during public execution, including actual teardown gas */
+  publicGas: Gas;
+
+  /**
+   * The actual gas used in the teardown phase.
+   */
+  teardownGas: Gas;
+
+  /**
+   * The gas billed for the transaction. This uses teardown gas limit instead of actual teardown gas.
+   */
+  billedGas: Gas;
+}

package/src/gas/index.ts

@@ -0,0 +1,4 @@
+export * from './gas.js';
+export * from './gas_fees.js';
+export * from './gas_settings.js';
+export * from './gas_used.js';

package/src/hash/hash.ts

@@ -0,0 +1,143 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2Hash, poseidon2HashWithSeparator, sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { ContractClassLog } from '../logs/index.js';
+import type { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+
+/**
+ * Computes a hash of a given verification key.
+ * @param vkBuf - The verification key as fields.
+ * @returns The hash of the verification key.
+ */
+export function hashVK(keyAsFields: Fr[]): Promise<Fr> {
+  return poseidon2Hash(keyAsFields);
+}
+
+/**
+ * Computes a note hash nonce, which will be used to create a unique note hash.
+ * @param nullifierZero - The first nullifier in the tx.
+ * @param noteHashIndex - The index of the note hash.
+ * @returns A note hash nonce.
+ */
+export function computeNoteHashNonce(nullifierZero: Fr, noteHashIndex: number): Promise<Fr> {
+  return poseidon2HashWithSeparator([nullifierZero, noteHashIndex], GeneratorIndex.NOTE_HASH_NONCE);
+}
+
+/**
+ * Computes a siloed note hash, given the contract address and the note hash itself.
+ * A siloed note hash effectively namespaces a note hash to a specific contract.
+ * @param contract - The contract address
+ * @param noteHash - The note hash to silo.
+ * @returns A siloed note hash.
+ */
+export function siloNoteHash(contract: AztecAddress, noteHash: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([contract, noteHash], GeneratorIndex.SILOED_NOTE_HASH);
+}
+
+/**
+ * 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 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);
+}
+
+/**
+ * Computes a siloed nullifier, given the contract address and the inner nullifier.
+ * A siloed nullifier effectively namespaces a nullifier to a specific contract.
+ * @param contract - The contract address.
+ * @param innerNullifier - The nullifier to silo.
+ * @returns A siloed nullifier.
+ */
+export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([contract, innerNullifier], GeneratorIndex.OUTER_NULLIFIER);
+}
+
+/**
+ * Computes a public data tree value ready for insertion.
+ * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
+ * @returns Value hash into a tree-insertion-ready value.
+
+ */
+export function computePublicDataTreeValue(value: Fr): Fr {
+  return value;
+}
+
+/**
+ * Computes a public data tree index from contract address and storage slot.
+ * @param contractAddress - Contract where insertion is occurring.
+ * @param storageSlot - Storage slot where insertion is occurring.
+ * @returns Public data tree index computed from contract address and storage slot.
+
+ */
+export function computePublicDataTreeLeafSlot(contractAddress: AztecAddress, storageSlot: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([contractAddress, storageSlot], GeneratorIndex.PUBLIC_LEAF_INDEX);
+}
+
+/**
+ * Computes the hash of a list of arguments.
+ * @param args - Arguments to hash.
+ * @returns Pedersen hash of the arguments.
+ */
+export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
+  if (args.length === 0) {
+    return Promise.resolve(Fr.ZERO);
+  }
+
+  return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
+}
+
+/**
+ * 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.
+ * @param secret - The secret to hash (could be generated however you want e.g. `Fr.random()`)
+ * @returns The hash
+ */
+export function computeSecretHash(secret: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([secret], GeneratorIndex.SECRET_HASH);
+}
+
+export async function computeL1ToL2MessageNullifier(contract: AztecAddress, messageHash: Fr, secret: Fr) {
+  const innerMessageNullifier = await poseidon2HashWithSeparator(
+    [messageHash, secret],
+    GeneratorIndex.MESSAGE_NULLIFIER,
+  );
+  return siloNullifier(contract, innerMessageNullifier);
+}
+
+/**
+ * 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 async function siloContractClassLog(log: ContractClassLog, contract: AztecAddress): Promise<ContractClassLog> {
+  const innerLog = log.clone();
+  if (contract.isZero()) {
+    return innerLog;
+  }
+  innerLog.fields[0] = await poseidon2Hash([contract, innerLog.fields[0]]);
+  return innerLog;
+}

package/src/hash/index.ts

@@ -0,0 +1,2 @@
+export * from './hash.js';
+export * from './map_slot.js';

package/src/hash/map_slot.ts

@@ -0,0 +1,18 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Computes the resulting storage slot for an entry in a map.
+ * @param mapSlot - The slot of the map within state.
+ * @param key - The key of the map.
+ * @returns The slot in the contract storage where the value is stored.
+ */
+export function deriveStorageSlotInMap(
+  mapSlot: Fr | bigint,
+  key: {
+    /** Convert key to a field. */
+    toField: () => Fr;
+  },
+): Promise<Fr> {
+  return poseidon2Hash([mapSlot, key.toField()]);
+}

package/src/interfaces/archiver.ts

@@ -0,0 +1,84 @@
+import type { ApiSchemaFor } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { inBlockSchemaFor } from '../block/in_block.js';
+import { L2Block } from '../block/l2_block.js';
+import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
+import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
+import {
+  ContractClassPublicSchema,
+  type ContractDataSource,
+  ContractInstanceWithAddressSchema,
+  PublicFunctionSchema,
+} from '../contract/index.js';
+import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
+import { LogFilterSchema } from '../logs/log_filter.js';
+import { PrivateLog } from '../logs/private_log.js';
+import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
+import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
+import { optional, schemas } from '../schemas/schemas.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { TxEffect } from '../tx/tx_effect.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { TxReceipt } from '../tx/tx_receipt.js';
+import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
+import type { L2LogsSource } from './l2_logs_source.js';
+
+export type ArchiverApi = Omit<
+  L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource & NullifierWithBlockSource,
+  'start' | 'stop'
+>;
+
+export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
+  getRollupAddress: z.function().args().returns(schemas.EthAddress),
+  getRegistryAddress: z.function().args().returns(schemas.EthAddress),
+  getBlockNumber: z.function().args().returns(schemas.Integer),
+  getProvenBlockNumber: z.function().args().returns(schemas.Integer),
+  getProvenL2EpochNumber: z.function().args().returns(schemas.Integer.optional()),
+  getBlock: z.function().args(schemas.Integer).returns(L2Block.schema.optional()),
+  getBlockHeader: z
+    .function()
+    .args(z.union([schemas.Integer, z.literal('latest')]))
+    .returns(BlockHeader.schema.optional()),
+  getBlocks: z
+    .function()
+    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(L2Block.schema)),
+  getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
+  getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
+  getL2SlotNumber: z.function().args().returns(schemas.BigInt),
+  getL2EpochNumber: z.function().args().returns(schemas.BigInt),
+  getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.schema)),
+  isEpochComplete: z.function().args(schemas.BigInt).returns(z.boolean()),
+  getL2Tips: z.function().args().returns(L2TipsSchema),
+  getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
+  getLogsByTags: z
+    .function()
+    .args(z.array(schemas.Fr))
+    .returns(z.array(z.array(TxScopedL2Log.schema))),
+  findNullifiersIndexesWithBlock: z
+    .function()
+    .args(z.number(), z.array(schemas.Fr))
+    .returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
+  getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
+  getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
+  getPublicFunction: z
+    .function()
+    .args(schemas.AztecAddress, schemas.FunctionSelector)
+    .returns(PublicFunctionSchema.optional()),
+  getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
+  getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
+  getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
+  getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
+  registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
+  getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),
+  getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
+  // TODO(#10007): Remove this method
+  addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
+  getContractFunctionName: z
+    .function()
+    .args(schemas.AztecAddress, schemas.FunctionSelector)
+    .returns(optional(z.string())),
+  getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
+};