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

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

@@ -0,0 +1,165 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+import {
+  MerkleTreeId,
+  type MerkleTreeWriteOperations,
+  PublicDataTreeLeaf,
+  PublicDataTreeLeafPreimage,
+} from '@aztec/stdlib/trees';
+import { GlobalVariables, TxEffect, TxHash } from '@aztec/stdlib/tx';
+import type { UInt32 } from '@aztec/stdlib/types';
+
+import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
+import type { IAvmExecutionOracle } from './interfaces.js';
+
+export class TXEOraclePublicContext implements IAvmExecutionOracle {
+  isAvm = true as const;
+
+  private logger: Logger;
+  private transientUniqueNoteHashes: Fr[] = [];
+  private transientSiloedNullifiers: Fr[] = [];
+  private publicDataWrites: PublicDataWrite[] = [];
+
+  constructor(
+    private contractAddress: AztecAddress,
+    private forkedWorldTrees: MerkleTreeWriteOperations,
+    private txRequestHash: Fr,
+    private globalVariables: GlobalVariables,
+  ) {
+    this.logger = createLogger('txe:public_context');
+
+    this.logger.debug('Entering Public Context', {
+      contractAddress,
+      blockNumber: globalVariables.blockNumber,
+      timestamp: globalVariables.timestamp,
+    });
+  }
+
+  avmOpcodeAddress(): Promise<AztecAddress> {
+    return Promise.resolve(this.contractAddress);
+  }
+
+  avmOpcodeSender(): Promise<AztecAddress> {
+    return Promise.resolve(AztecAddress.ZERO); // todo: change?
+  }
+
+  avmOpcodeBlockNumber(): Promise<UInt32> {
+    return Promise.resolve(this.globalVariables.blockNumber);
+  }
+
+  avmOpcodeTimestamp(): Promise<bigint> {
+    return Promise.resolve(this.globalVariables.timestamp);
+  }
+
+  avmOpcodeIsStaticCall(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  avmOpcodeChainId(): Promise<Fr> {
+    return Promise.resolve(this.globalVariables.chainId);
+  }
+
+  avmOpcodeVersion(): Promise<Fr> {
+    return Promise.resolve(this.globalVariables.version);
+  }
+
+  async avmOpcodeEmitNullifier(nullifier: Fr) {
+    const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
+    this.transientSiloedNullifiers.push(siloedNullifier);
+  }
+
+  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);
+  }
+
+  async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
+    const nullifier = await siloNullifier(targetAddress, innerNullifier!);
+
+    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;
+  }
+
+  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.forkedWorldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+      new PublicDataTreeLeaf(dataWrite.leafSlot, dataWrite.value).toBuffer(),
+    ]);
+  }
+
+  async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
+    const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
+
+    const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      leafSlot.toBigInt(),
+    );
+
+    const value =
+      !lowLeafResult || !lowLeafResult.alreadyPresent
+        ? Fr.ZERO
+        : (
+            (await this.forkedWorldTrees.getLeafPreimage(
+              MerkleTreeId.PUBLIC_DATA_TREE,
+              lowLeafResult.index,
+            )) as PublicDataTreeLeafPreimage
+          ).leaf.value;
+
+    this.logger.debug('AVM storage read', { slot, value });
+
+    return value;
+  }
+
+  async close(): Promise<L2Block> {
+    this.logger.debug('Exiting Public Context, building block with collected side effects', {
+      blockNumber: this.globalVariables.blockNumber,
+    });
+
+    const txEffect = this.makeTxEffect();
+    await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
+
+    const block = new L2Block(
+      makeAppendOnlyTreeSnapshot(),
+      await makeTXEBlockHeader(this.forkedWorldTrees, this.globalVariables),
+      new Body([txEffect]),
+    );
+
+    await this.forkedWorldTrees.close();
+
+    this.logger.debug('Exited PublicContext with built block', {
+      blockNumber: block.number,
+      txEffects: block.body.txEffects,
+    });
+
+    return block;
+  }
+
+  private makeTxEffect(): TxEffect {
+    const txEffect = TxEffect.empty();
+
+    txEffect.noteHashes = this.transientUniqueNoteHashes;
+    txEffect.nullifiers = [this.txRequestHash, ...this.transientSiloedNullifiers];
+
+    txEffect.publicDataWrites = this.publicDataWrites;
+    // TODO: support public logs
+
+    txEffect.txHash = new TxHash(new Fr(this.globalVariables.blockNumber));
+
+    return txEffect;
+  }
+}