@aztec/txe 0.71.0 → 0.73.0

package/src/txe_service/txe_service.ts

@@ -1,10 +1,9 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { L2Block, MerkleTreeId, SimulationError } from '@aztec/circuit-types';
+import { MerkleTreeId, SimulationError } from '@aztec/circuit-types';
 import {
-  BlockHeader,
   Fr,
   FunctionSelector,
-  PublicDataTreeLeaf,
+  PublicDataWrite,
   PublicKeys,
   computePartialAddress,
   getContractInstanceFromDeployParams,
@@ -20,8 +19,7 @@ import { getCanonicalProtocolContract } from '@aztec/protocol-contracts/bundle';
 import { enrichPublicSimulationError } from '@aztec/pxe';
 import { type TypedOracle } from '@aztec/simulator/client';
 import { HashedValuesCache } from '@aztec/simulator/server';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { MerkleTrees } from '@aztec/world-state';
+import { NativeWorldStateService } from '@aztec/world-state';
 
 import { TXE } from '../oracle/txe_oracle.js';
 import {
@@ -42,18 +40,20 @@ export class TXEService {
 
   static async init(logger: Logger) {
     const store = openTmpStore(true);
-    const trees = await MerkleTrees.new(store, getTelemetryClient(), logger);
     const executionCache = new HashedValuesCache();
+    const nativeWorldStateService = await NativeWorldStateService.tmp();
+    const baseFork = await nativeWorldStateService.fork();
+
     const keyStore = new KeyStore(store);
     const txeDatabase = new TXEDatabase(store);
     // Register protocol contracts.
     for (const name of protocolContractNames) {
-      const { contractClass, instance, artifact } = getCanonicalProtocolContract(name);
+      const { contractClass, instance, artifact } = await getCanonicalProtocolContract(name);
       await txeDatabase.addContractArtifact(contractClass.id, artifact);
       await txeDatabase.addContractInstance(instance);
     }
     logger.debug(`TXE service initialized`);
-    const txe = new TXE(logger, trees, executionCache, keyStore, txeDatabase);
+    const txe = await TXE.create(logger, executionCache, keyStore, txeDatabase, nativeWorldStateService, baseFork);
     const service = new TXEService(logger, txe);
     await service.advanceBlocksBy(toSingle(new Fr(1n)));
     return service;
@@ -69,21 +69,10 @@ export class TXEService {
   async advanceBlocksBy(blocks: ForeignCallSingle) {
     const nBlocks = fromSingle(blocks).toNumber();
     this.logger.debug(`time traveling ${nBlocks} blocks`);
-    const trees = (this.typedOracle as TXE).getTrees();
-
-    await (this.typedOracle as TXE).commitState();
 
     for (let i = 0; i < nBlocks; i++) {
       const blockNumber = await this.typedOracle.getBlockNumber();
-      const header = BlockHeader.empty();
-      const l2Block = L2Block.empty();
-      header.state = await trees.getStateReference(true);
-      header.globalVariables.blockNumber = new Fr(blockNumber);
-      await trees.appendLeaves(MerkleTreeId.ARCHIVE, [header.hash()]);
-      l2Block.archive.root = Fr.fromBuffer((await trees.getTreeInfo(MerkleTreeId.ARCHIVE, true)).root);
-      l2Block.header = header;
-      this.logger.debug(`Block ${blockNumber} created, header hash ${header.hash().toString()}`);
-      await trees.handleL2BlockAndMessages(l2Block, []);
+      await (this.typedOracle as TXE).commitState();
       (this.typedOracle as TXE).setBlockNumber(blockNumber + 1);
     }
     return toForeignCallResult([]);
@@ -95,8 +84,8 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  deriveKeys(secret: ForeignCallSingle) {
-    const keys = (this.typedOracle as TXE).deriveKeys(fromSingle(secret));
+  async deriveKeys(secret: ForeignCallSingle) {
+    const keys = await (this.typedOracle as TXE).deriveKeys(fromSingle(secret));
     return toForeignCallResult(keys.publicKeys.toFields().map(toSingle));
   }
 
@@ -116,7 +105,7 @@ export class TXEService {
       `Deploy ${artifact.name} with initializer ${initializerStr}(${decodedArgs}) and public keys hash ${publicKeysHashFr}`,
     );
 
-    const instance = getContractInstanceFromDeployParams(artifact, {
+    const instance = await getContractInstanceFromDeployParams(artifact, {
       constructorArgs: decodedArgs,
       skipArgsDecoding: true,
       salt: Fr.ONE,
@@ -145,22 +134,20 @@ export class TXEService {
     startStorageSlot: ForeignCallSingle,
     values: ForeignCallArray,
   ) {
-    const trees = (this.typedOracle as TXE).getTrees();
     const startStorageSlotFr = fromSingle(startStorageSlot);
     const valuesFr = fromArray(values);
     const contractAddressFr = addressFromSingle(contractAddress);
-    const db = await trees.getLatest();
 
-    const publicDataWrites = valuesFr.map((value, i) => {
-      const storageSlot = startStorageSlotFr.add(new Fr(i));
-      this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
-      return new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
-    });
-    await db.batchInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      publicDataWrites.map(write => write.toBuffer()),
-      0,
+    const publicDataWrites = await Promise.all(
+      valuesFr.map(async (value, i) => {
+        const storageSlot = startStorageSlotFr.add(new Fr(i));
+        this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
+        return new PublicDataWrite(await computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
+      }),
     );
+
+    await (this.typedOracle as TXE).addPublicDataWrites(publicDataWrites);
+
     return toForeignCallResult([toArray(publicDataWrites.map(write => write.value))]);
   }
 
@@ -177,10 +164,10 @@ export class TXEService {
   }
 
   async addAccount(secret: ForeignCallSingle) {
-    const keys = (this.typedOracle as TXE).deriveKeys(fromSingle(secret));
+    const keys = await (this.typedOracle as TXE).deriveKeys(fromSingle(secret));
     const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
     const artifact = SchnorrAccountContractArtifact;
-    const instance = getContractInstanceFromDeployParams(artifact, {
+    const instance = await getContractInstanceFromDeployParams(artifact, {
       constructorArgs: args,
       skipArgsDecoding: true,
       salt: Fr.ONE,
@@ -194,7 +181,7 @@ export class TXEService {
     await (this.typedOracle as TXE).addContractArtifact(artifact);
 
     const keyStore = (this.typedOracle as TXE).getKeyStore();
-    const completeAddress = await keyStore.addAccount(fromSingle(secret), computePartialAddress(instance));
+    const completeAddress = await keyStore.addAccount(fromSingle(secret), await computePartialAddress(instance));
     const accountStore = (this.typedOracle as TXE).getTXEDatabase();
     await accountStore.setAccount(completeAddress.address, completeAddress);
     this.logger.debug(`Created account ${completeAddress.address}`);
@@ -271,11 +258,6 @@ export class TXEService {
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
-  async storeArrayInExecutionCache(args: ForeignCallArray) {
-    const hash = await this.typedOracle.storeArrayInExecutionCache(fromArray(args));
-    return toForeignCallResult([toSingle(hash)]);
-  }
-
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
   async storeInExecutionCache(_length: ForeignCallSingle, values: ForeignCallArray) {
     const returnsHash = await this.typedOracle.storeInExecutionCache(fromArray(values));
@@ -534,16 +516,6 @@ export class TXEService {
     return toForeignCallResult([toSingle(await this.typedOracle.getVersion())]);
   }
 
-  async addNullifiers(contractAddress: ForeignCallSingle, _length: ForeignCallSingle, nullifiers: ForeignCallArray) {
-    await (this.typedOracle as TXE).addNullifiers(addressFromSingle(contractAddress), fromArray(nullifiers));
-    return toForeignCallResult([]);
-  }
-
-  async addNoteHashes(contractAddress: ForeignCallSingle, _length: ForeignCallSingle, noteHashes: ForeignCallArray) {
-    await (this.typedOracle as TXE).addNoteHashes(addressFromSingle(contractAddress), fromArray(noteHashes));
-    return toForeignCallResult([]);
-  }
-
   async getBlockHeader(blockNumber: ForeignCallSingle) {
     const header = await this.typedOracle.getBlockHeader(fromSingle(blockNumber).toNumber());
     if (!header) {

package/src/util/txe_public_contract_data_source.ts

@@ -32,8 +32,8 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
     const contractClass = await this.txeOracle.getContractDataOracle().getContractClass(id);
     const artifact = await this.txeOracle.getContractDataOracle().getContractArtifact(id);
-    const tree = new PrivateFunctionsTree(artifact);
-    const privateFunctionsRoot = tree.getFunctionTreeRoot();
+    const tree = await PrivateFunctionsTree.create(artifact);
+    const privateFunctionsRoot = await tree.getFunctionTreeRoot();
 
     const publicFunctions: PublicFunction[] = [];
     if (contractClass!.packedBytecode.length > 0) {
@@ -57,7 +57,7 @@ export class TXEPublicContractDataSource implements ContractDataSource {
 
   async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
     const contractClass = await this.txeOracle.getContractDataOracle().getContractClass(id);
-    return Promise.resolve(computePublicBytecodeCommitment(contractClass.packedBytecode));
+    return computePublicBytecodeCommitment(contractClass.packedBytecode);
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
@@ -79,9 +79,14 @@ export class TXEPublicContractDataSource implements ContractDataSource {
     if (!artifact) {
       return undefined;
     }
-    const func = artifact.functions.find(f =>
-      FunctionSelector.fromNameAndParameters({ name: f.name, parameters: f.parameters }).equals(selector),
+    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);
   }
 

package/src/util/txe_world_state_db.ts

@@ -3,19 +3,21 @@ import {
   type AztecAddress,
   type ContractDataSource,
   Fr,
-  PublicDataTreeLeaf,
   type PublicDataTreeLeafPreimage,
+  PublicDataWrite,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { WorldStateDB } from '@aztec/simulator/server';
 
+import { type TXE } from '../oracle/txe_oracle.js';
+
 export class TXEWorldStateDB extends WorldStateDB {
-  constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource) {
+  constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, private txe: TXE) {
     super(merkleDb, dataSource);
   }
 
   override async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
-    const leafSlot = computePublicDataTreeLeafSlot(contract, slot).toBigInt();
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
 
     const lowLeafResult = await this.merkleDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
 
@@ -31,11 +33,10 @@ export class TXEWorldStateDB extends WorldStateDB {
   }
 
   override async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
-    await this.merkleDb.batchInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      [new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(contract, slot), newValue).toBuffer()],
-      0,
-    );
+    await this.txe.addPublicDataWrites([
+      new PublicDataWrite(await computePublicDataTreeLeafSlot(contract, slot), newValue),
+    ]);
+
     return newValue.toBigInt();
   }