@aztec/simulator 0.34.0 → 0.35.0

package/src/public/setup_phase_manager.ts

@@ -0,0 +1,66 @@
+import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
+import {
+  type GlobalVariables,
+  type Header,
+  type Proof,
+  type PublicKernelCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_executor.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+/**
+ * The phase manager responsible for performing the fee preparation phase.
+ */
+export class SetupPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public phase: PublicKernelPhase = PublicKernelPhase.SETUP,
+  ) {
+    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
+  }
+
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
+  ) {
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+    const [kernelInputs, publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
+    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+    await this.publicStateDB.checkpoint();
+
+    // Return a list of setup proving requests
+    const kernelRequests = kernelInputs.map(input => {
+      const request: PublicKernelRequest = {
+        type: PublicKernelType.SETUP,
+        inputs: input,
+      };
+      return request;
+    });
+    return {
+      kernelRequests,
+      kernelInputs,
+      publicKernelOutput,
+      publicKernelProof,
+      revertReason,
+      returnValues: undefined,
+    };
+  }
+}

package/src/public/tail_phase_manager.ts

@@ -0,0 +1,120 @@
+import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
+import {
+  type Fr,
+  type GlobalVariables,
+  type Header,
+  type KernelCircuitPublicInputs,
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  type Proof,
+  type PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+  type SideEffect,
+  makeEmptyProof,
+  mergeAccumulatedData,
+  sortByCounter,
+} from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_executor.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+export class TailPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
+  ) {
+    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
+  }
+
+  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+    const [inputs, finalKernelOutput] = await this.runTailKernelCircuit(
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    ).catch(
+      // the abstract phase manager throws if simulation gives error in non-revertible phase
+      async err => {
+        await this.publicStateDB.rollbackToCommit();
+        throw err;
+      },
+    );
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
+
+    // Return a tail proving request
+    const request: PublicKernelRequest = {
+      type: PublicKernelType.TAIL,
+      inputs: inputs,
+    };
+
+    return {
+      kernelRequests: [request],
+      publicKernelOutput: previousPublicKernelOutput,
+      finalKernelOutput,
+      publicKernelProof: makeEmptyProof(),
+      revertReason: undefined,
+      returnValues: undefined,
+    };
+  }
+
+  private async runTailKernelCircuit(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
+    const [inputs, output] = await this.simulate(previousOutput, previousProof);
+
+    // Temporary hack. Should sort them in the tail circuit.
+    const noteHashes = mergeAccumulatedData(
+      MAX_NEW_NOTE_HASHES_PER_TX,
+      previousOutput.endNonRevertibleData.newNoteHashes,
+      previousOutput.end.newNoteHashes,
+    );
+    output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
+
+    return [inputs, output];
+  }
+
+  private async simulate(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+
+    const { validationRequests, endNonRevertibleData, end } = previousOutput;
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      validationRequests.nullifierReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+    const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
+      validationRequests.nullifierNonExistentReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+
+    // We take a deep copy (clone) of these to pass to the prover
+    const inputs = new PublicKernelTailCircuitPrivateInputs(
+      previousKernel,
+      nullifierReadRequestHints,
+      nullifierNonExistentReadRequestHints,
+    );
+    return [inputs.clone(), await this.publicKernel.publicKernelCircuitTail(inputs)];
+  }
+
+  private sortNoteHashes<N extends number>(noteHashes: Tuple<SideEffect, N>): Tuple<Fr, N> {
+    return sortByCounter(noteHashes.map(n => ({ ...n, counter: n.counter.toNumber() }))).map(n => n.value) as Tuple<
+      Fr,
+      N
+    >;
+  }
+}

package/src/public/teardown_phase_manager.ts

@@ -0,0 +1,66 @@
+import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
+import {
+  type GlobalVariables,
+  type Header,
+  type Proof,
+  type PublicKernelCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_executor.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+/**
+ * The phase manager responsible for performing the fee preparation phase.
+ */
+export class TeardownPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public phase: PublicKernelPhase = PublicKernelPhase.TEARDOWN,
+  ) {
+    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
+  }
+
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
+  ) {
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+    const [kernelInputs, publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
+    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+    await this.publicStateDB.checkpoint();
+
+    // Return a list of teardown proving requests
+    const kernelRequests = kernelInputs.map(input => {
+      const request: PublicKernelRequest = {
+        type: PublicKernelType.TEARDOWN,
+        inputs: input,
+      };
+      return request;
+    });
+    return {
+      kernelRequests,
+      kernelInputs,
+      publicKernelOutput,
+      publicKernelProof,
+      revertReason,
+      returnValues: undefined,
+    };
+  }
+}

package/src/public/transitional_adaptors.ts

@@ -5,6 +5,7 @@ import {
   ContractStorageRead,
   ContractStorageUpdateRequest,
   FunctionData,
+  Gas,
   type GlobalVariables,
   type Header,
   L2ToL1Message,
@@ -16,11 +17,12 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { type AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { type AvmMachineState } from '../avm/avm_machine_state.js';
 import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
 import { type JournalData } from '../avm/journal/journal.js';
 import { Mov } from '../avm/opcodes/memory.js';
 import { createSimulationError } from '../common/errors.js';
-import { PackedArgsCache, SideEffectCounter } from '../index.js';
+import { PackedValuesCache, SideEffectCounter } from '../index.js';
 import { type PublicExecution, type PublicExecutionResult } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
 
@@ -42,15 +44,17 @@ export function createAvmExecutionEnvironment(
     current.callContext.msgSender, // TODO: origin is not available
     current.callContext.msgSender,
     current.callContext.portalContractAddress,
-    /*feePerL1Gas=*/ Fr.zero(),
-    /*feePerL2Gas=*/ Fr.zero(),
-    /*feePerDaGas=*/ Fr.zero(),
+    globalVariables.gasFees.feePerL1Gas,
+    globalVariables.gasFees.feePerL2Gas,
+    globalVariables.gasFees.feePerDaGas,
     /*contractCallDepth=*/ Fr.zero(),
     header,
     globalVariables,
     current.callContext.isStaticCall,
     current.callContext.isDelegateCall,
     current.args,
+    current.callContext.gasSettings,
+    current.callContext.transactionFee,
     current.functionData.selector,
   );
 }
@@ -62,9 +66,12 @@ export function createPublicExecutionContext(avmContext: AvmContext, calldata: F
     storageContractAddress: avmContext.environment.storageAddress,
     portalContractAddress: avmContext.environment.portal,
     functionSelector: avmContext.environment.temporaryFunctionSelector,
+    gasLeft: Gas.from(avmContext.machineState.gasLeft),
     isDelegateCall: avmContext.environment.isDelegateCall,
     isStaticCall: avmContext.environment.isStaticCall,
     sideEffectCounter: sideEffectCounter,
+    gasSettings: avmContext.environment.gasSettings,
+    transactionFee: avmContext.environment.transactionFee,
   });
   const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
   const execution: PublicExecution = {
@@ -73,7 +80,7 @@ export function createPublicExecutionContext(avmContext: AvmContext, calldata: F
     args: calldata,
     functionData,
   };
-  const packedArgs = PackedArgsCache.create([]);
+  const packedArgs = PackedValuesCache.create([]);
 
   const context = new PublicExecutionContext(
     execution,
@@ -101,6 +108,7 @@ export async function convertAvmResults(
   executionContext: PublicExecutionContext,
   newWorldState: JournalData,
   result: AvmContractCallResults,
+  endMachineState: AvmMachineState,
 ): Promise<PublicExecutionResult> {
   const execution = executionContext.execution;
 
@@ -162,6 +170,7 @@ export async function convertAvmResults(
     unencryptedLogs,
     reverted: result.reverted,
     revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
+    gasLeft: endMachineState.gasLeft,
   };
 }
 

package/src/public/utils.ts

@@ -0,0 +1,31 @@
+import { type Tx } from '@aztec/circuit-types';
+import { CallRequest } from '@aztec/circuits.js';
+
+/**
+ * Looks at the side effects of a transaction and returns the highest counter
+ * @param tx - A transaction
+ * @returns The highest side effect counter in the transaction so far
+ */
+export function lastSideEffectCounter(tx: Tx): number {
+  const data = tx.data.forPublic!;
+  const sideEffectCounters = [
+    ...data.endNonRevertibleData.newNoteHashes,
+    ...data.endNonRevertibleData.newNullifiers,
+    ...data.endNonRevertibleData.publicCallStack,
+    ...data.end.newNoteHashes,
+    ...data.end.newNullifiers,
+    ...data.end.publicCallStack,
+  ];
+
+  let max = 0;
+  for (const sideEffect of sideEffectCounters) {
+    if (sideEffect instanceof CallRequest) {
+      // look at both start and end counters because for enqueued public calls start > 0 while end === 0
+      max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
+    } else {
+      max = Math.max(max, sideEffect.counter.toNumber());
+    }
+  }
+
+  return max;
+}

package/src/simulator/acvm_native.ts

@@ -1,4 +1,6 @@
 import { randomBytes } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -7,6 +9,26 @@ import fs from 'fs/promises';
 
 import { type SimulationProvider } from './simulation_provider.js';
 
+const logger = createDebugLogger('aztec:acvm-native');
+
+export enum ACVM_RESULT {
+  SUCCESS,
+  FAILURE,
+}
+
+export type ACVMSuccess = {
+  status: ACVM_RESULT.SUCCESS;
+  duration: number;
+  witness: Map<number, string>;
+};
+
+export type ACVMFailure = {
+  status: ACVM_RESULT.FAILURE;
+  reason: string;
+};
+
+export type ACVMResult = ACVMSuccess | ACVMFailure;
+
 /**
  * Parses a TOML format witness map string into a Map structure
  * @param outputString - The witness map in TOML format
@@ -29,7 +51,8 @@ function parseIntoWitnessMap(outputString: string) {
  * @param inputWitness - The circuit's input witness
  * @param bytecode - The circuit bytecode
  * @param workingDirectory - A directory to use for temporary files by the ACVM
- * @param pathToAcvm - The path to the ACVm binary
+ * @param pathToAcvm - The path to the ACVM binary
+ * @param outputFilename - If specified, the output will be stored as a file, encoded using Bincode
  * @returns The completed partial witness outputted from the circuit
  */
 export async function executeNativeCircuit(
@@ -37,7 +60,8 @@ export async function executeNativeCircuit(
   bytecode: Buffer,
   workingDirectory: string,
   pathToAcvm: string,
-) {
+  outputFilename?: string,
+): Promise<ACVMResult> {
   const bytecodeFilename = 'bytecode';
   const witnessFilename = 'input_witness.toml';
 
@@ -47,55 +71,69 @@ export async function executeNativeCircuit(
     witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
   });
 
-  // In case the directory is still around from some time previously, remove it
-  await fs.rm(workingDirectory, { recursive: true, force: true });
-  // Create the new working directory
-  await fs.mkdir(workingDirectory, { recursive: true });
-  // Write the bytecode and input witness to the working directory
-  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
-  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
-
-  // Execute the ACVM using the given args
-  const args = [
-    `execute`,
-    `--working-directory`,
-    `${workingDirectory}`,
-    `--bytecode`,
-    `${bytecodeFilename}`,
-    `--input-witness`,
-    `${witnessFilename}`,
-    `--print`,
-  ];
-  const processPromise = new Promise<string>((resolve, reject) => {
-    let outputWitness = Buffer.alloc(0);
-    let errorBuffer = Buffer.alloc(0);
-    const acvm = proc.spawn(pathToAcvm, args);
-    acvm.stdout.on('data', data => {
-      outputWitness = Buffer.concat([outputWitness, data]);
-    });
-    acvm.stderr.on('data', data => {
-      errorBuffer = Buffer.concat([errorBuffer, data]);
-    });
-    acvm.on('close', code => {
-      if (code === 0) {
-        resolve(outputWitness.toString('utf-8'));
-      } else {
-        reject(errorBuffer.toString('utf-8'));
-      }
-    });
-  });
+  try {
+    // Check that the directory exists
+    await fs.access(workingDirectory);
+  } catch (error) {
+    return { status: ACVM_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
+  }
 
   try {
+    // Write the bytecode and input witness to the working directory
+    await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+    await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+
+    // Execute the ACVM using the given args
+    const args = [
+      `execute`,
+      `--working-directory`,
+      `${workingDirectory}`,
+      `--bytecode`,
+      `${bytecodeFilename}`,
+      `--input-witness`,
+      `${witnessFilename}`,
+      '--print',
+      '--output-witness',
+      'output-witness',
+    ];
+
+    logger.debug(`Calling ACVM with ${args.join(' ')}`);
+
+    const processPromise = new Promise<string>((resolve, reject) => {
+      let outputWitness = Buffer.alloc(0);
+      let errorBuffer = Buffer.alloc(0);
+      const acvm = proc.spawn(pathToAcvm, args);
+      acvm.stdout.on('data', data => {
+        outputWitness = Buffer.concat([outputWitness, data]);
+      });
+      acvm.stderr.on('data', data => {
+        errorBuffer = Buffer.concat([errorBuffer, data]);
+      });
+      acvm.on('close', code => {
+        if (code === 0) {
+          resolve(outputWitness.toString('utf-8'));
+        } else {
+          logger.error(`From ACVM: ${errorBuffer.toString('utf-8')}`);
+          reject(errorBuffer.toString('utf-8'));
+        }
+      });
+    });
+
+    const duration = new Timer();
     const output = await processPromise;
-    return parseIntoWitnessMap(output);
-  } finally {
-    // Clean up the working directory before we leave
-    await fs.rm(workingDirectory, { recursive: true, force: true });
+    if (outputFilename) {
+      const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
+      await fs.copyFile(outputWitnessFileName, outputFilename);
+    }
+    const witness = parseIntoWitnessMap(output);
+    return { status: ACVM_RESULT.SUCCESS, witness, duration: duration.ms() };
+  } catch (error) {
+    return { status: ACVM_RESULT.FAILURE, reason: `${error}` };
   }
 }
 
 export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string) {}
+  constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
   async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
 
@@ -103,10 +141,19 @@ export class NativeACVMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
 
     // Provide a unique working directory so we don't get clashes with parallel executions
-    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
+    const directory = `${this.workingDirectory}/${randomBytes(8).toString('hex')}`;
+
+    await fs.mkdir(directory, { recursive: true });
+
     // Execute the circuit
-    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
+    const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename);
+
+    await fs.rm(directory, { force: true, recursive: true });
+
+    if (result.status == ACVM_RESULT.FAILURE) {
+      throw new Error(`Failed to generate witness: ${result.reason}`);
+    }
 
-    return _witnessMap;
+    return result.witness;
   }
 }

package/src/simulator/acvm_wasm.ts

@@ -1,3 +1,4 @@
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import {
@@ -26,9 +27,12 @@ export class WASMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
-      throw Error('unexpected oracle during execution');
-    });
+    const _witnessMap = await executeCircuitWithBlackBoxSolver(
+      await getSolver(),
+      decodedBytecode,
+      input,
+      foreignCallHandler, // handle calls to debug_log
+    );
 
     return _witnessMap;
   }

package/dest/common/packed_args_cache.d.ts

@@ -1,28 +0,0 @@
-import { PackedArguments } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-/**
- * A cache for packed arguments during transaction execution.
- */
-export declare class PackedArgsCache {
-    private cache;
-    constructor(initialArguments?: PackedArguments[]);
-    /**
-     * Creates a new packed arguments cache.
-     * @param initialArguments - The initial arguments to add to the cache.
-     * @returns The new packed arguments cache.
-     */
-    static create(initialArguments?: PackedArguments[]): PackedArgsCache;
-    /**
-     * Unpacks packed arguments.
-     * @param hash - The hash of the packed arguments.
-     * @returns The unpacked arguments.
-     */
-    unpack(hash: Fr): Fr[];
-    /**
-     * Packs arguments.
-     * @param args - The arguments to pack.
-     * @returns The hash of the packed arguments.
-     */
-    pack(args: Fr[]): Fr;
-}
-//# sourceMappingURL=packed_args_cache.d.ts.map

package/dest/common/packed_args_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"packed_args_cache.d.ts","sourceRoot":"","sources":["../../src/common/packed_args_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAExC;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAoB;gBAErB,gBAAgB,GAAE,eAAe,EAAO;IAOpD;;;;OAIG;WACW,MAAM,CAAC,gBAAgB,GAAE,eAAe,EAAO;IAI7D;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE;IAW7B;;;;OAIG;IACI,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE;CAQvB"}

package/dest/common/packed_args_cache.js

@@ -1,50 +0,0 @@
-import { PackedArguments } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-/**
- * A cache for packed arguments during transaction execution.
- */
-export class PackedArgsCache {
-    constructor(initialArguments = []) {
-        this.cache = new Map();
-        for (const initialArg of initialArguments) {
-            this.cache.set(initialArg.hash.toBigInt(), initialArg.args);
-        }
-    }
-    /**
-     * Creates a new packed arguments cache.
-     * @param initialArguments - The initial arguments to add to the cache.
-     * @returns The new packed arguments cache.
-     */
-    static create(initialArguments = []) {
-        return new PackedArgsCache(initialArguments);
-    }
-    /**
-     * Unpacks packed arguments.
-     * @param hash - The hash of the packed arguments.
-     * @returns The unpacked arguments.
-     */
-    unpack(hash) {
-        if (hash.equals(Fr.ZERO)) {
-            return [];
-        }
-        const packedArgs = this.cache.get(hash.value);
-        if (!packedArgs) {
-            throw new Error(`Packed arguments for hash ${hash.toString()} not found in cache`);
-        }
-        return packedArgs;
-    }
-    /**
-     * Packs arguments.
-     * @param args - The arguments to pack.
-     * @returns The hash of the packed arguments.
-     */
-    pack(args) {
-        if (args.length === 0) {
-            return Fr.ZERO;
-        }
-        const packedArguments = PackedArguments.fromArgs(args);
-        this.cache.set(packedArguments.hash.value, packedArguments.args);
-        return packedArguments.hash;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2VkX2FyZ3NfY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbW9uL3BhY2tlZF9hcmdzX2NhY2hlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFeEM7O0dBRUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUcxQixZQUFZLG1CQUFzQyxFQUFFO1FBQ2xELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQztRQUN2QixLQUFLLE1BQU0sVUFBVSxJQUFJLGdCQUFnQixFQUFFLENBQUM7WUFDMUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsRUFBRSxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDOUQsQ0FBQztJQUNILENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksTUFBTSxDQUFDLE1BQU0sQ0FBQyxtQkFBc0MsRUFBRTtRQUMzRCxPQUFPLElBQUksZUFBZSxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDL0MsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxNQUFNLENBQUMsSUFBUTtRQUNwQixJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDekIsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO1FBQ0QsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzlDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNoQixNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixJQUFJLENBQUMsUUFBUSxFQUFFLHFCQUFxQixDQUFDLENBQUM7UUFDckYsQ0FBQztRQUNELE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksSUFBSSxDQUFDLElBQVU7UUFDcEIsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3RCLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQztRQUNqQixDQUFDO1FBQ0QsTUFBTSxlQUFlLEdBQUcsZUFBZSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2RCxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDakUsT0FBTyxlQUFlLENBQUMsSUFBSSxDQUFDO0lBQzlCLENBQUM7Q0FDRiJ9