@aztec/txe 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/oracle/interfaces.ts

@@ -0,0 +1,83 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt32, UInt64 } from '@aztec/stdlib/types';
+
+// These interfaces complement the ones defined in PXE, and combined with those contain the full list of oracles used by
+// aztec-nr. In particular, these include the ones needed to run Brillig code associated to #[external("public")] functions that has
+// not been transpiled (e.g. in the context of a Noir test) as well as the ones associated with managing the state of
+// such a Noir test (deploying contracts, manipulating block time, making calls, etc) - the so called 'top level test
+// context'.
+
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("public")] function.
+ *
+ * Note that real contracts have their Brillig calls to these be transpiled into opcodes, the oracles are only executed
+ * as such when running the original Brillig code, e.g. when invoking functions that interact with a PublicContext
+ * directly in a Noir test.
+ */
+export interface IAvmExecutionOracle {
+  isAvm: true;
+
+  avmOpcodeAddress(): Promise<AztecAddress>;
+  avmOpcodeSender(): Promise<AztecAddress>;
+  avmOpcodeBlockNumber(): Promise<UInt32>;
+  avmOpcodeTimestamp(): Promise<bigint>;
+  avmOpcodeIsStaticCall(): Promise<boolean>;
+  avmOpcodeChainId(): Promise<Fr>;
+  avmOpcodeVersion(): Promise<Fr>;
+  avmOpcodeEmitNullifier(nullifier: Fr): Promise<void>;
+  avmOpcodeEmitNoteHash(noteHash: Fr): Promise<void>;
+  avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean>;
+  avmOpcodeStorageWrite(slot: Fr, value: Fr): Promise<void>;
+  avmOpcodeStorageRead(slot: Fr): Promise<Fr>;
+}
+
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */
+export interface ITxeExecutionOracle {
+  isTxe: true;
+
+  txeGetNextBlockNumber(): Promise<number>;
+  txeGetNextBlockTimestamp(): Promise<UInt64>;
+  txeAdvanceBlocksBy(blocks: number): Promise<void>;
+  txeAdvanceTimestampBy(duration: UInt64): void;
+  txeDeploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
+  txeCreateAccount(secret: Fr): Promise<CompleteAddress>;
+  txeAddAccount(
+    artifact: ContractArtifact,
+    instance: ContractInstanceWithAddress,
+    secret: Fr,
+  ): Promise<CompleteAddress>;
+  txeAddAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  txeGetLastBlockTimestamp(): Promise<bigint>;
+  txeGetLastTxEffects(): Promise<{
+    txHash: TxHash;
+    noteHashes: Fr[];
+    nullifiers: Fr[];
+  }>;
+  txePrivateCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+    argsHash: Fr,
+    isStaticCall: boolean,
+  ): Promise<Fr[]>;
+  txeSimulateUtilityFunction(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    args: Fr[],
+  ): Promise<Fr[]>;
+  txePublicCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress,
+    calldata: Fr[],
+    isStaticCall: boolean,
+  ): Promise<Fr[]>;
+}

package/src/oracle/txe_oracle_public_context.ts

@@ -1,30 +1,25 @@
-import {
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-} from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Body, L2Block } from '@aztec/stdlib/block';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-import { makeAppendOnlyTreeSnapshot, makeContentCommitment } from '@aztec/stdlib/testing';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
 import {
-  AppendOnlyTreeSnapshot,
   MerkleTreeId,
   type MerkleTreeWriteOperations,
   PublicDataTreeLeaf,
   PublicDataTreeLeafPreimage,
 } from '@aztec/stdlib/trees';
-import { BlockHeader, GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
 import type { UInt32 } from '@aztec/stdlib/types';
 
-import { TXETypedOracle } from './txe_typed_oracle.js';
+import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
+import type { IAvmExecutionOracle } from './interfaces.js';
+
+export class TXEOraclePublicContext implements IAvmExecutionOracle {
+  isAvm = true as const;
 
-export class TXEOraclePublicContext extends TXETypedOracle {
   private logger: Logger;
   private transientUniqueNoteHashes: Fr[] = [];
   private transientSiloedNullifiers: Fr[] = [];
@@ -32,80 +27,85 @@ export class TXEOraclePublicContext extends TXETypedOracle {
 
   constructor(
     private contractAddress: AztecAddress,
-    private worldTrees: MerkleTreeWriteOperations,
+    private forkedWorldTrees: MerkleTreeWriteOperations,
     private txRequestHash: Fr,
     private globalVariables: GlobalVariables,
   ) {
-    super();
     this.logger = createLogger('txe:public_context');
 
-    this.logger.debug('Entering PublicContext', {
+    this.logger.debug('Entering Public Context', {
       contractAddress,
       blockNumber: globalVariables.blockNumber,
       timestamp: globalVariables.timestamp,
     });
   }
 
-  override avmOpcodeAddress(): Promise<AztecAddress> {
+  avmOpcodeAddress(): Promise<AztecAddress> {
     return Promise.resolve(this.contractAddress);
   }
 
-  override avmOpcodeBlockNumber(): Promise<UInt32> {
+  avmOpcodeSender(): Promise<AztecAddress> {
+    return Promise.resolve(AztecAddress.ZERO); // todo: change?
+  }
+
+  avmOpcodeBlockNumber(): Promise<UInt32> {
     return Promise.resolve(this.globalVariables.blockNumber);
   }
 
-  override avmOpcodeTimestamp(): Promise<bigint> {
+  avmOpcodeTimestamp(): Promise<bigint> {
     return Promise.resolve(this.globalVariables.timestamp);
   }
 
-  override avmOpcodeIsStaticCall(): Promise<boolean> {
+  avmOpcodeIsStaticCall(): Promise<boolean> {
     return Promise.resolve(false);
   }
 
-  override avmOpcodeChainId(): Promise<Fr> {
+  avmOpcodeChainId(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.chainId);
   }
 
-  override avmOpcodeVersion(): Promise<Fr> {
+  avmOpcodeVersion(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.version);
   }
 
-  override async avmOpcodeEmitNullifier(nullifier: Fr) {
+  async avmOpcodeEmitNullifier(nullifier: Fr) {
     const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
     this.transientSiloedNullifiers.push(siloedNullifier);
   }
 
-  override async avmOpcodeEmitNoteHash(noteHash: Fr) {
+  async avmOpcodeEmitNoteHash(noteHash: Fr) {
     const siloedNoteHash = await siloNoteHash(this.contractAddress, noteHash);
     // TODO: make the note hash unique - they are only siloed right now
     this.transientUniqueNoteHashes.push(siloedNoteHash);
   }
 
-  override async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
+  async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
     const nullifier = await siloNullifier(targetAddress, innerNullifier!);
 
-    const treeIndex = (await this.worldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    const treeIndex = (
+      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()])
+    )[0];
     const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(nullifier));
 
     return treeIndex !== undefined || transientIndex !== undefined;
   }
 
-  override async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
+  async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
     this.logger.debug('AVM storage write', { slot, value });
 
     const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
 
     this.publicDataWrites.push(dataWrite);
 
-    await this.worldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+    await this.forkedWorldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
       new PublicDataTreeLeaf(dataWrite.leafSlot, dataWrite.value).toBuffer(),
     ]);
   }
 
-  override async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
+  async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
     const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
 
-    const lowLeafResult = await this.worldTrees.getPreviousValueIndex(
+    const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(
       MerkleTreeId.PUBLIC_DATA_TREE,
       leafSlot.toBigInt(),
     );
@@ -114,7 +114,7 @@ export class TXEOraclePublicContext extends TXETypedOracle {
       !lowLeafResult || !lowLeafResult.alreadyPresent
         ? Fr.ZERO
         : (
-            (await this.worldTrees.getLeafPreimage(
+            (await this.forkedWorldTrees.getLeafPreimage(
               MerkleTreeId.PUBLIC_DATA_TREE,
               lowLeafResult.index,
             )) as PublicDataTreeLeafPreimage
@@ -126,20 +126,20 @@ export class TXEOraclePublicContext extends TXETypedOracle {
   }
 
   async close(): Promise<L2Block> {
-    this.logger.debug('Exiting PublicContext, building block with collected side effects', {
+    this.logger.debug('Exiting Public Context, building block with collected side effects', {
       blockNumber: this.globalVariables.blockNumber,
     });
 
     const txEffect = this.makeTxEffect();
-    await this.insertSideEffectIntoWorldTrees(txEffect);
+    await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
 
     const block = new L2Block(
-      makeAppendOnlyTreeSnapshot(this.globalVariables.blockNumber),
-      await this.makeBlockHeader(),
+      makeAppendOnlyTreeSnapshot(),
+      await makeTXEBlockHeader(this.forkedWorldTrees, this.globalVariables),
       new Body([txEffect]),
     );
 
-    await this.worldTrees.close();
+    await this.forkedWorldTrees.close();
 
     this.logger.debug('Exited PublicContext with built block', {
       blockNumber: block.number,
@@ -162,37 +162,4 @@ export class TXEOraclePublicContext extends TXETypedOracle {
 
     return txEffect;
   }
-
-  private async insertSideEffectIntoWorldTrees(txEffect: TxEffect) {
-    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-
-    await this.worldTrees.appendLeaves(
-      MerkleTreeId.NOTE_HASH_TREE,
-      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
-
-    await this.worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
-
-    // We do not need to add public data writes because we apply them as we go.
-
-    await this.worldTrees.batchInsert(
-      MerkleTreeId.NULLIFIER_TREE,
-      padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(nullifier => nullifier.toBuffer()),
-      NULLIFIER_SUBTREE_HEIGHT,
-    );
-  }
-
-  private async makeBlockHeader(): Promise<BlockHeader> {
-    const stateReference = await this.worldTrees.getStateReference();
-    const archiveInfo = await this.worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
-
-    return new BlockHeader(
-      new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
-      makeContentCommitment(),
-      stateReference,
-      this.globalVariables,
-      Fr.ZERO,
-      Fr.ZERO,
-    );
-  }
 }