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

package/src/tx/public_simulation_output.ts

@@ -7,8 +7,8 @@ import { z } from 'zod';
 import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import { CombinedConstantData } from '../kernel/combined_constant_data.js';
 import { TxEffect } from '../tx/tx_effect.js';
+import { GlobalVariables } from './global_variables.js';
 
 /** Return values of simulating a circuit. */
 export type ProcessReturnValues = Fr[] | undefined;
@@ -50,7 +50,7 @@ export class NestedProcessReturnValues {
 export class PublicSimulationOutput {
   constructor(
     public revertReason: SimulationError | undefined,
-    public constants: CombinedConstantData,
+    public globalVariables: GlobalVariables,
     public txEffect: TxEffect,
     public publicReturnValues: NestedProcessReturnValues[],
     public gasUsed: GasUsed,
@@ -60,7 +60,7 @@ export class PublicSimulationOutput {
     return z
       .object({
         revertReason: SimulationError.schema.optional(),
-        constants: CombinedConstantData.schema,
+        globalVariables: GlobalVariables.schema,
         txEffect: TxEffect.schema,
         publicReturnValues: z.array(NestedProcessReturnValues.schema),
         gasUsed: z.object({
@@ -74,7 +74,7 @@ export class PublicSimulationOutput {
         fields =>
           new PublicSimulationOutput(
             fields.revertReason,
-            fields.constants,
+            fields.globalVariables,
             fields.txEffect,
             fields.publicReturnValues,
             fields.gasUsed,
@@ -85,7 +85,7 @@ export class PublicSimulationOutput {
   static async random() {
     return new PublicSimulationOutput(
       await SimulationError.random(),
-      CombinedConstantData.empty(),
+      GlobalVariables.empty(),
       TxEffect.empty(),
       times(2, NestedProcessReturnValues.random),
       { teardownGas: Gas.random(), totalGas: Gas.random(), publicGas: Gas.random(), billedGas: Gas.random() },

package/src/tx/simulated_tx.ts

@@ -1,26 +1,59 @@
-import type { ZodFor } from '@aztec/foundation/schemas';
+import { type ZodFor, optional } from '@aztec/foundation/schemas';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
+import { type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
+import {
+  type ContractInstanceWithAddress,
+  ContractInstanceWithAddressSchema,
+} from '../contract/interfaces/contract_instance.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import {
-  type PrivateKernelProverProfileResult,
-  PrivateKernelProverProfileResultSchema,
-} from '../kernel/private_kernel_prover_profile_result.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import {
   PrivateCallExecutionResult,
   PrivateExecutionResult,
-  collectEnqueuedPublicFunctionCalls,
-  collectPublicTeardownFunctionCall,
   collectSortedContractClassLogs,
 } from './private_execution_result.js';
+import { type SimulationStats, SimulationStatsSchema } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
 
+/*
+ * If passed during the execution of a user circuit, the contract function simulator will replace the instance and class
+ * of the contract with the one provided in the overrides for that address. An example use case
+ * would be overriding your own account contract so that valid signatures don't have to be provided while simulating.
+ */
+export type ContractOverrides = Record<
+  string /* AztecAddress as string */,
+  { instance: ContractInstanceWithAddress; artifact: ContractArtifact }
+>;
+
+/*
+ * Optional values that can be overridden during simulation. In order to simulate a transaction with these
+ * set, it *must* be run without the kernel circuits, or validations will fail
+ */
+export class SimulationOverrides {
+  constructor(public contracts?: ContractOverrides) {}
+
+  static get schema() {
+    return z
+      .object({
+        contracts: optional(
+          z.record(
+            z.string(),
+            z.object({ instance: ContractInstanceWithAddressSchema, artifact: ContractArtifactSchema }),
+          ),
+        ),
+      })
+      .transform(({ contracts }) => {
+        return new SimulationOverrides(contracts);
+      });
+  }
+}
+
 export class PrivateSimulationResult {
   constructor(
     public privateExecutionResult: PrivateExecutionResult,
@@ -31,31 +64,25 @@ export class PrivateSimulationResult {
     return accumulatePrivateReturnValues(this.privateExecutionResult);
   }
 
-  toSimulatedTx(): Tx {
+  async toSimulatedTx(): Promise<Tx> {
     const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-
-    const tx = new Tx(
-      this.publicInputs,
-      ClientIvcProof.empty(),
-      contractClassLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-    return tx;
+
+    return await Tx.create({
+      data: this.publicInputs,
+      clientIvcProof: ClientIvcProof.empty(),
+      contractClassLogFields: contractClassLogs,
+      publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
+    });
   }
 }
 
-export class TxSimulationResult extends PrivateSimulationResult {
+export class TxSimulationResult {
   constructor(
-    privateExecutionResult: PrivateExecutionResult,
-    publicInputs: PrivateKernelTailCircuitPublicInputs,
+    public privateExecutionResult: PrivateExecutionResult,
+    public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public publicOutput?: PublicSimulationOutput,
-    public profileResult?: PrivateKernelProverProfileResult,
-  ) {
-    super(privateExecutionResult, publicInputs);
-  }
+    public stats?: SimulationStats,
+  ) {}
 
   get gasUsed(): GasUsed {
     return (
@@ -74,7 +101,7 @@ export class TxSimulationResult extends PrivateSimulationResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         publicOutput: PublicSimulationOutput.schema.optional(),
-        profileResult: PrivateKernelProverProfileResultSchema.optional(),
+        stats: optional(SimulationStatsSchema),
       })
       .transform(TxSimulationResult.from);
   }
@@ -84,24 +111,20 @@ export class TxSimulationResult extends PrivateSimulationResult {
       fields.privateExecutionResult,
       fields.publicInputs,
       fields.publicOutput,
-      fields.profileResult,
+      fields.stats,
     );
   }
 
-  getPublicReturnValues() {
-    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
-  }
-
   static fromPrivateSimulationResultAndPublicOutput(
     privateSimulationResult: PrivateSimulationResult,
     publicOutput?: PublicSimulationOutput,
-    profileResult?: PrivateKernelProverProfileResult,
+    stats?: SimulationStats,
   ) {
     return new TxSimulationResult(
       privateSimulationResult.privateExecutionResult,
       privateSimulationResult.publicInputs,
       publicOutput,
-      profileResult,
+      stats,
     );
   }
 
@@ -112,50 +135,17 @@ export class TxSimulationResult extends PrivateSimulationResult {
       await PublicSimulationOutput.random(),
     );
   }
-}
-
-export class TxProvingResult {
-  constructor(
-    public privateExecutionResult: PrivateExecutionResult,
-    public publicInputs: PrivateKernelTailCircuitPublicInputs,
-    public clientIvcProof: ClientIvcProof,
-  ) {}
 
-  toTx(): Tx {
-    const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-
-    const tx = new Tx(
-      this.publicInputs,
-      this.clientIvcProof,
-      contractClassLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-    return tx;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        privateExecutionResult: PrivateExecutionResult.schema,
-        publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
-      })
-      .transform(TxProvingResult.from);
+  getPrivateReturnValues() {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
   }
 
-  static from(fields: FieldsOf<TxProvingResult>) {
-    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+  toSimulatedTx(): Promise<Tx> {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
   }
 
-  static async random() {
-    return new TxProvingResult(
-      await PrivateExecutionResult.random(),
-      PrivateKernelTailCircuitPublicInputs.empty(),
-      ClientIvcProof.empty(),
-    );
+  getPublicReturnValues() {
+    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
   }
 }
 
@@ -170,8 +160,8 @@ export function accumulatePrivateReturnValues(executionResult: PrivateExecutionR
     executionResult: PrivateCallExecutionResult,
   ): NestedProcessReturnValues => {
     const acc = new NestedProcessReturnValues(executionResult.returnValues);
-    acc.nested = executionResult.nestedExecutions.map(nestedExecution =>
-      collectPrivateReturnValuesRecursive(nestedExecution),
+    acc.nested = executionResult.nestedExecutionResults.map(nestedExecutionResult =>
+      collectPrivateReturnValuesRecursive(nestedExecutionResult),
     );
     return acc;
   };

package/src/tx/state_reference.ts

@@ -1,4 +1,10 @@
-import { STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  STATE_REFERENCE_LENGTH,
+} from '@aztec/constants';
+import type { ViemStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -33,7 +39,7 @@ export class StateReference {
   }
 
   toBuffer() {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
   }
 
@@ -61,12 +67,34 @@ export class StateReference {
     return new StateReference(l1ToL2MessageTree, partial);
   }
 
+  static fromViem(stateReference: ViemStateReference) {
+    return new StateReference(
+      AppendOnlyTreeSnapshot.fromViem(stateReference.l1ToL2MessageTree),
+      PartialStateReference.fromViem(stateReference.partialStateReference),
+    );
+  }
+
   static empty(): StateReference {
-    return new StateReference(AppendOnlyTreeSnapshot.zero(), PartialStateReference.empty());
+    return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
+  }
+
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
+  toViem(): ViemStateReference {
+    return {
+      l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),
+      partialStateReference: this.partial.toViem(),
+    };
+  }
+
+  toAbi(): [ReturnType<AppendOnlyTreeSnapshot['toAbi']>, ReturnType<PartialStateReference['toAbi']>] {
+    return [this.l1ToL2MessageTree.toAbi(), [...this.partial.toAbi()]];
   }
 
   isEmpty(): boolean {
-    return this.l1ToL2MessageTree.isZero() && this.partial.isEmpty();
+    return this.l1ToL2MessageTree.isEmpty() && this.partial.isEmpty();
   }
 
   toInspect() {
@@ -78,6 +106,27 @@ export class StateReference {
     };
   }
 
+  /**
+   * Validates the trees in world state have the expected number of leaves (multiple of number of insertions per tx)
+   */
+  public validate() {
+    if (this.l1ToL2MessageTree.nextAvailableLeafIndex % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP !== 0) {
+      throw new Error(
+        `Invalid L1 to L2 message tree next available leaf index ${this.l1ToL2MessageTree.nextAvailableLeafIndex} (must be a multiple of ${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP})`,
+      );
+    }
+    if (this.partial.noteHashTree.nextAvailableLeafIndex % MAX_NOTE_HASHES_PER_TX !== 0) {
+      throw new Error(
+        `Invalid note hash tree next available leaf index ${this.partial.noteHashTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NOTE_HASHES_PER_TX})`,
+      );
+    }
+    if (this.partial.nullifierTree.nextAvailableLeafIndex % MAX_NULLIFIERS_PER_TX !== 0) {
+      throw new Error(
+        `Invalid nullifier tree next available leaf index ${this.partial.nullifierTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NULLIFIERS_PER_TX})`,
+      );
+    }
+  }
+
   [inspect.custom]() {
     return `StateReference {
   l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
@@ -88,6 +137,6 @@ export class StateReference {
   }
 
   public equals(other: this): boolean {
-    return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
   }
 }

package/src/tx/tree_snapshots.ts

@@ -12,10 +12,10 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
  */
 export class TreeSnapshots {
   constructor(
-    public readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot,
-    public readonly noteHashTree: AppendOnlyTreeSnapshot,
-    public readonly nullifierTree: AppendOnlyTreeSnapshot,
-    public readonly publicDataTree: AppendOnlyTreeSnapshot,
+    public l1ToL2MessageTree: AppendOnlyTreeSnapshot,
+    public noteHashTree: AppendOnlyTreeSnapshot,
+    public nullifierTree: AppendOnlyTreeSnapshot,
+    public publicDataTree: AppendOnlyTreeSnapshot,
   ) {}
 
   static get schema() {
@@ -52,7 +52,7 @@ export class TreeSnapshots {
   }
 
   toBuffer() {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
   }
 
@@ -84,19 +84,19 @@ export class TreeSnapshots {
 
   static empty(): TreeSnapshots {
     return new TreeSnapshots(
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
     );
   }
 
   isEmpty(): boolean {
     return (
-      this.l1ToL2MessageTree.isZero() &&
-      this.noteHashTree.isZero() &&
-      this.nullifierTree.isZero() &&
-      this.publicDataTree.isZero()
+      this.l1ToL2MessageTree.isEmpty() &&
+      this.noteHashTree.isEmpty() &&
+      this.nullifierTree.isEmpty() &&
+      this.publicDataTree.isEmpty()
     );
   }