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

package/src/util/encoding.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -31,7 +32,7 @@ export function fromArray(obj: ForeignCallArray) {
 /**
  * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
  * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
- * @returns
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
  */
 export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer {
   if (uintBitSize % 8 !== 0) {
@@ -41,14 +42,50 @@ export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffe
   return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
 }
 
-export function toSingle(obj: Fr | AztecAddress): ForeignCallSingle {
-  return obj.toString().slice(2);
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ForeignCallArray and ForeignCallSingle values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export function fromUintBoundedVec(storage: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  const boundedStorage = storage.slice(0, fromSingle(length).toNumber());
+  return Buffer.concat(boundedStorage.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}
+
+// Just like toACVMField in yarn-project/simulator/src/private/acvm/serialize.ts but returns a ForeignCallSingle
+// instead of an ACVMField.
+export function toSingle(
+  value: AztecAddress | EthAddress | Fr | Buffer | boolean | number | bigint,
+): ForeignCallSingle {
+  let valueAsField;
+  if (Buffer.isBuffer(value)) {
+    valueAsField = Fr.fromBuffer(value);
+  } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+    valueAsField = new Fr(value);
+  } else if (typeof value === 'string') {
+    valueAsField = Fr.fromHexString(value);
+  } else {
+    valueAsField = value;
+  }
+  return valueAsField.toString().slice(2);
 }
 
 export function toArray(objs: Fr[]): ForeignCallArray {
   return objs.map(obj => obj.toString());
 }
 
+export function toSingleOrArray(value: Fr | Fr[]) {
+  return Array.isArray(value) ? value.map(toSingle) : toSingle(value);
+}
+
 export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
   return toArray(Array.from(buffer).map(byte => new Fr(byte)));
 }
@@ -57,24 +94,61 @@ export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
  * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
  * If the input array is shorter than the maxLen, it pads the result with zeros,
  * so that nr can correctly coerce this result into a BoundedVec.
- * @param array
+ * @param bVecStorage - The array underlying the BoundedVec.
  * @param maxLen - the max length of the BoundedVec.
  * @returns a tuple representing a BoundedVec.
  */
-export function arrayToBoundedVec(array: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle] {
-  if (array.length > maxLen) {
-    throw new Error(`Array of length ${array.length} larger than maxLen ${maxLen}`);
+export function arrayToBoundedVec(
+  bVecStorage: ForeignCallArray,
+  maxLen: number,
+): [ForeignCallArray, ForeignCallSingle] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
   }
-  const lengthDiff = maxLen - array.length;
+  const lengthDiff = maxLen - bVecStorage.length;
   // We pad the array to the maxLen of the BoundedVec.
   const zeroPaddingArray = toArray(Array(lengthDiff).fill(new Fr(0)));
 
   // These variable names match with the BoundedVec members in nr:
-  const storage = array.concat(zeroPaddingArray);
-  const len = toSingle(new Fr(array.length));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toSingle(new Fr(bVecStorage.length));
   return [storage, len];
 }
 
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export function arrayOfArraysToBoundedVecOfArrays(
+  bVecStorage: ForeignCallArray[],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ForeignCallArray, ForeignCallSingle] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+
+  // Check that all nested arrays have length nestedArrayLength
+  if (!bVecStorage.every(nestedArray => nestedArray.length === nestedArrayLength)) {
+    throw new Error(
+      `Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`,
+    );
+  }
+
+  const flattenedStorage = bVecStorage.flat();
+
+  const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+
+  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(new Fr(0)));
+
+  // At last we get the actual length of the BoundedVec and return the values.
+  const len = toSingle(new Fr(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}
+
 export function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]) {
   return { values: obj };
 }

package/src/util/{txe_account_data_provider.ts → txe_account_store.ts}

@@ -2,7 +2,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
 
-export class TXEAccountDataProvider {
+export class TXEAccountStore {
   #accounts: AztecAsyncMap<string, Buffer>;
 
   constructor(store: AztecAsyncKVStore) {

package/src/util/txe_contract_store.ts

@@ -0,0 +1,36 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { Fr } from '@aztec/aztec.js/fields';
+import { ContractStore } from '@aztec/pxe/server';
+
+export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+
+/*
+ * A contract store that stores contract artifacts with their hashes. Since
+ * TXE typically deploys the same contract again and again for multiple tests, caching
+ * the *very* expensive artifact hash computation improves testing speed significantly.
+ */
+export class TXEContractStore extends ContractStore {
+  #artifactHashes: Map<string, Buffer> = new Map();
+
+  public override async addContractArtifact(
+    id: Fr,
+    artifact: ContractArtifact | ContractArtifactWithHash,
+  ): Promise<void> {
+    if ('artifactHash' in artifact) {
+      this.#artifactHashes.set(id.toString(), artifact.artifactHash.toBuffer());
+    }
+    await super.addContractArtifact(id, artifact);
+  }
+
+  public override async getContractArtifact(
+    contractClassId: Fr,
+  ): Promise<ContractArtifact | ContractArtifactWithHash | undefined> {
+    const artifact = await super.getContractArtifact(contractClassId);
+    if (artifact && this.#artifactHashes.has(contractClassId.toString())) {
+      (artifact as ContractArtifactWithHash).artifactHash = Fr.fromBuffer(
+        this.#artifactHashes.get(contractClassId.toString())!,
+      );
+    }
+    return artifact;
+  }
+}

package/src/util/txe_public_contract_data_source.ts

@@ -1,67 +1,70 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { PrivateFunctionsTree } from '@aztec/pxe/server';
-import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractStore } from '@aztec/pxe/server';
+import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ContractClassPublic,
   type ContractDataSource,
   type ContractInstanceWithAddress,
-  type PublicFunction,
+  computePrivateFunctionsRoot,
   computePublicBytecodeCommitment,
+  getContractClassPrivateFunctionFromArtifact,
 } from '@aztec/stdlib/contract';
 
-import type { TXE } from '../oracle/txe_oracle.js';
-
 export class TXEPublicContractDataSource implements ContractDataSource {
-  constructor(private txeOracle: TXE) {}
-
-  async getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined> {
-    const bytecode = await this.txeOracle.getContractDataProvider().getBytecode(address, selector);
-    if (!bytecode) {
-      return undefined;
-    }
-    return { bytecode, selector };
-  }
+  #privateFunctionsRoot: Map<string, Buffer> = new Map();
+  constructor(
+    private blockNumber: BlockNumber,
+    private contractStore: ContractStore,
+  ) {}
 
-  getBlockNumber(): Promise<number> {
-    return this.txeOracle.getBlockNumber();
+  getBlockNumber(): Promise<BlockNumber> {
+    return Promise.resolve(this.blockNumber);
   }
 
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
-    const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
-    const tree = await PrivateFunctionsTree.create(artifact);
-    const privateFunctionsRoot = await tree.getFunctionTreeRoot();
+    const contractClass = await this.contractStore.getContractClass(id);
+    if (!contractClass) {
+      return;
+    }
+    const artifact = await this.contractStore.getContractArtifact(id);
+    if (!artifact) {
+      return;
+    }
 
-    const publicFunctions: PublicFunction[] = [];
-    if (contractClass!.packedBytecode.length > 0) {
-      publicFunctions.push({
-        selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-        bytecode: contractClass!.packedBytecode,
-      });
+    let privateFunctionsRoot;
+    if (!this.#privateFunctionsRoot.has(id.toString())) {
+      const privateFunctions = await Promise.all(
+        artifact.functions
+          .filter(fn => fn.functionType === FunctionType.PRIVATE)
+          .map(fn => getContractClassPrivateFunctionFromArtifact(fn)),
+      );
+      privateFunctionsRoot = await computePrivateFunctionsRoot(privateFunctions);
+      this.#privateFunctionsRoot.set(id.toString(), privateFunctionsRoot.toBuffer());
+    } else {
+      privateFunctionsRoot = Fr.fromBuffer(this.#privateFunctionsRoot.get(id.toString())!);
     }
 
     return {
       id,
       artifactHash: contractClass!.artifactHash,
       packedBytecode: contractClass!.packedBytecode,
-      publicFunctions: publicFunctions,
-      privateFunctionsRoot: new Fr(privateFunctionsRoot!.root),
+      privateFunctionsRoot,
       version: contractClass!.version,
       privateFunctions: [],
-      unconstrainedFunctions: [],
+      utilityFunctions: [],
     };
   }
 
   async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
-    return computePublicBytecodeCommitment(contractClass.packedBytecode);
+    const contractClass = await this.contractStore.getContractClass(id);
+    return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-    return { ...instance, address };
+    const instance = await this.contractStore.getContractInstance(address);
+    return instance && { ...instance, address };
   }
 
   getContractClassIds(): Promise<Fr[]> {
@@ -69,33 +72,15 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
-    const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-    return this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
+    const instance = await this.contractStore.getContractInstance(address);
+    return instance && this.contractStore.getContractArtifact(instance.currentContractClassId);
   }
 
-  async getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    const artifact = await this.getContractArtifact(address);
-    if (!artifact) {
-      return undefined;
-    }
-    const functionSelectorsAndNames = await Promise.all(
-      artifact.functions.map(async f => ({
-        name: f.name,
-        selector: await FunctionSelector.fromNameAndParameters({ name: f.name, parameters: f.parameters }),
-      })),
-    );
-    const func = functionSelectorsAndNames.find(f => f.selector.equals(selector));
-
-    return Promise.resolve(func?.name);
-  }
-
-  registerContractFunctionSignatures(_address: AztecAddress, _signatures: []): Promise<void> {
-    return Promise.resolve();
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return await this.contractStore.getDebugFunctionName(address, selector);
   }
 
-  // TODO(#10007): Remove this method.
-  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
-    // We don't really need to do anything for the txe here
+  registerContractFunctionSignatures(_signatures: []): Promise<void> {
     return Promise.resolve();
   }
 }

package/src/utils/block_creation.ts

@@ -0,0 +1,94 @@
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+} from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Body, L2Block, L2BlockHeader } from '@aztec/stdlib/block';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */
+export function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr {
+  return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
+}
+
+export async function insertTxEffectIntoWorldTrees(
+  txEffect: TxEffect,
+  worldTrees: MerkleTreeWriteOperations,
+): Promise<void> {
+  await worldTrees.appendLeaves(
+    MerkleTreeId.NOTE_HASH_TREE,
+    padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+  );
+
+  await worldTrees.batchInsert(
+    MerkleTreeId.NULLIFIER_TREE,
+    padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(nullifier => nullifier.toBuffer()),
+    NULLIFIER_SUBTREE_HEIGHT,
+  );
+
+  await worldTrees.appendLeaves(
+    MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+    padArrayEnd<Fr, number>(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+  );
+
+  // We do not need to add public data writes because we apply them as we go.
+}
+
+export async function makeTXEBlockHeader(
+  worldTrees: MerkleTreeWriteOperations,
+  globalVariables: GlobalVariables,
+): Promise<L2BlockHeader> {
+  const stateReference = await worldTrees.getStateReference();
+  const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  return new L2BlockHeader(
+    new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+    Fr.ZERO,
+    Fr.ZERO,
+    stateReference,
+    globalVariables,
+    Fr.ZERO,
+    Fr.ZERO,
+    Fr.ZERO,
+    Fr.ZERO,
+  );
+}
+
+/**
+ * Creates an L2Block with proper archive chaining.
+ * This function:
+ * 1. Gets the current archive state as lastArchive for the header
+ * 2. Creates the block header
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @param worldTrees - The world trees to read/write from
+ * @param globalVariables - Global variables for the block
+ * @param txEffects - Transaction effects to include in the block
+ * @returns The created L2Block with proper archive chaining
+ */
+export async function makeTXEBlock(
+  worldTrees: MerkleTreeWriteOperations,
+  globalVariables: GlobalVariables,
+  txEffects: TxEffect[],
+): Promise<L2Block> {
+  const header = await makeTXEBlockHeader(worldTrees, globalVariables);
+
+  // Update the archive tree with this block's header hash
+  await worldTrees.updateArchive(header.toBlockHeader());
+
+  // Get the new archive state after updating
+  const newArchiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+  const newArchive = new AppendOnlyTreeSnapshot(new Fr(newArchiveInfo.root), Number(newArchiveInfo.size));
+
+  return new L2Block(newArchive, header, new Body(txEffects));
+}

package/src/utils/tx_effect_creation.ts

@@ -0,0 +1,38 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+
+export async function makeTxEffect(
+  noteCache: ExecutionNoteCache,
+  protocolNullifier: Fr,
+  txBlockNumber: BlockNumber,
+): Promise<TxEffect> {
+  const txEffect = TxEffect.empty();
+
+  const { usedProtocolNullifierForNonces } = noteCache.finish();
+  const nonceGenerator = usedProtocolNullifierForNonces ? protocolNullifier : noteCache.getAllNullifiers()[0];
+
+  txEffect.noteHashes = await Promise.all(
+    noteCache
+      .getAllNotes()
+      .map(async (pendingNote, i) =>
+        computeUniqueNoteHash(
+          await computeNoteHashNonce(nonceGenerator, i),
+          await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption),
+        ),
+      ),
+  );
+
+  // Nullifiers are already siloed
+  txEffect.nullifiers = noteCache.getAllNullifiers();
+
+  if (usedProtocolNullifierForNonces) {
+    txEffect.nullifiers.unshift(protocolNullifier);
+  }
+
+  txEffect.txHash = new TxHash(new Fr(txBlockNumber));
+
+  return txEffect;
+}