@aztec/txe 0.0.1-commit.f295ac2 → 0.0.1-commit.f504929

package/src/index.ts

@@ -9,9 +9,12 @@ import { Fr } from '@aztec/aztec.js/fields';
 import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import type { Logger } from '@aztec/foundation/log';
-import { type ProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { ContractStore } from '@aztec/pxe/server';
 import { computeArtifactHash } from '@aztec/stdlib/contract';
+import type { ContractArtifactWithHash } from '@aztec/stdlib/contract';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 import { zodFor } from '@aztec/stdlib/schemas';
 
@@ -29,22 +32,29 @@ import {
   type ForeignCallResult,
   ForeignCallResultSchema,
   type ForeignCallSingle,
+  addressFromSingle,
   fromArray,
   fromSingle,
   toSingle,
 } from './util/encoding.js';
-import type { ContractArtifactWithHash } from './util/txe_contract_store.js';
 
 const sessions = new Map<number, TXESession>();
 
 /*
  * TXE typically has to load the same contract artifacts over and over again for multiple tests,
- * so we cache them here to avoid both loading them from disk repeatedly and computing their artifact hashes
+ * so we cache them here to avoid loading from disk repeatedly.
+ *
+ * The in-flight map coalesces concurrent requests for the same cache key so that
+ * computeArtifactHash (very expensive) is only run once even under parallelism.
  */
 const TXEArtifactsCache = new Map<
   string,
   { artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }
 >();
+const TXEArtifactsCacheInFlight = new Map<
+  string,
+  Promise<{ artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }>
+>();
 
 type TXEForeignCallInput = {
   session_id: number;
@@ -68,7 +78,7 @@ const TXEForeignCallInputSchema = zodFor<TXEForeignCallInput>()(
 );
 
 class TXEDispatcher {
-  private protocolContracts!: ProtocolContract[];
+  private contractStore!: ContractStore;
 
   constructor(private logger: Logger) {}
 
@@ -96,6 +106,8 @@ class TXEDispatcher {
 
     const decodedArgs = fromArray(inputs[3] as ForeignCallArray);
     const secret = fromSingle(inputs[4] as ForeignCallSingle);
+    const salt = fromSingle(inputs[5] as ForeignCallSingle);
+    const deployer = addressFromSingle(inputs[6] as ForeignCallSingle);
     const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
     const publicKeysHash = await publicKeys.hash();
 
@@ -126,7 +138,7 @@ class TXEDispatcher {
 
     const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs
       .map(arg => arg.toString())
-      .join('-')}-${publicKeysHash}-${fileHash}`;
+      .join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
 
     let instance;
     let artifact: ContractArtifactWithHash;
@@ -135,29 +147,36 @@ class TXEDispatcher {
       this.logger.debug(`Using cached artifact for ${cacheKey}`);
       ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
     } else {
-      this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-      const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
-      const artifactWithoutHash = loadContractArtifact(artifactJSON);
-      artifact = {
-        ...artifactWithoutHash,
-        // Artifact hash is *very* expensive to compute, so we do it here once
-        // and the TXE contract data provider can cache it
-        artifactHash: await computeArtifactHash(artifactWithoutHash),
-      };
-      this.logger.debug(
-        `Deploy ${
-          artifact.name
-        } with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
-      );
-      instance = await getContractInstanceFromInstantiationParams(artifact, {
-        constructorArgs: decodedArgs,
-        skipArgsDecoding: true,
-        salt: Fr.ONE,
-        publicKeys,
-        constructorArtifact: initializer ? initializer : undefined,
-        deployer: AztecAddress.ZERO,
-      });
-      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+      if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+        this.logger.debug(`Loading compiled artifact ${artifactPath}`);
+        const compute = async () => {
+          const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
+          const artifactWithoutHash = loadContractArtifact(artifactJSON);
+          const computedArtifact: ContractArtifactWithHash = {
+            ...artifactWithoutHash,
+            // Artifact hash is *very* expensive to compute, so we do it here once
+            // and the TXE contract data provider can cache it
+            artifactHash: await computeArtifactHash(artifactWithoutHash),
+          };
+          this.logger.debug(
+            `Deploy ${computedArtifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
+          );
+          const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+            constructorArgs: decodedArgs,
+            skipArgsDecoding: true,
+            salt,
+            publicKeys,
+            constructorArtifact: initializer ? initializer : undefined,
+            deployer,
+          });
+          const result = { artifact: computedArtifact, instance: computedInstance };
+          TXEArtifactsCache.set(cacheKey, result);
+          TXEArtifactsCacheInFlight.delete(cacheKey);
+          return result;
+        };
+        TXEArtifactsCacheInFlight.set(cacheKey, compute());
+      }
+      ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey)!);
     }
 
     inputs.splice(0, 1, artifact, instance, toSingle(secret));
@@ -175,23 +194,35 @@ class TXEDispatcher {
       this.logger.debug(`Using cached artifact for ${cacheKey}`);
       ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
     } else {
-      const keys = await deriveKeys(secret);
-      const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
-      artifact = {
-        ...SchnorrAccountContractArtifact,
-        // Artifact hash is *very* expensive to compute, so we do it here once
-        // and the TXE contract data provider can cache it
-        artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact),
-      };
-      instance = await getContractInstanceFromInstantiationParams(artifact, {
-        constructorArgs: args,
-        skipArgsDecoding: true,
-        salt: Fr.ONE,
-        publicKeys: keys.publicKeys,
-        constructorArtifact: 'constructor',
-        deployer: AztecAddress.ZERO,
-      });
-      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+      if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+        const compute = async () => {
+          const keys = await deriveKeys(secret);
+          const args = [
+            keys.publicKeys.masterIncomingViewingPublicKey.x,
+            keys.publicKeys.masterIncomingViewingPublicKey.y,
+          ];
+          const computedArtifact: ContractArtifactWithHash = {
+            ...SchnorrAccountContractArtifact,
+            // Artifact hash is *very* expensive to compute, so we do it here once
+            // and the TXE contract data provider can cache it
+            artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact),
+          };
+          const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+            constructorArgs: args,
+            skipArgsDecoding: true,
+            salt: Fr.ONE,
+            publicKeys: keys.publicKeys,
+            constructorArtifact: 'constructor',
+            deployer: AztecAddress.ZERO,
+          });
+          const result = { artifact: computedArtifact, instance: computedInstance };
+          TXEArtifactsCache.set(cacheKey, result);
+          TXEArtifactsCacheInFlight.delete(cacheKey);
+          return result;
+        };
+        TXEArtifactsCacheInFlight.set(cacheKey, compute());
+      }
+      ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey)!);
     }
 
     inputs.splice(0, 0, artifact, instance);
@@ -204,20 +235,26 @@ class TXEDispatcher {
 
     if (!sessions.has(sessionId)) {
       this.logger.debug(`Creating new session ${sessionId}`);
-      if (!this.protocolContracts) {
-        this.protocolContracts = await Promise.all(
-          protocolContractNames.map(name => new BundledProtocolContractsProvider().getProtocolContractArtifact(name)),
-        );
+      if (!this.contractStore) {
+        const kvStore = await openTmpStore('txe-contracts');
+        this.contractStore = new ContractStore(kvStore);
+        const provider = new BundledProtocolContractsProvider();
+        for (const name of protocolContractNames) {
+          const { instance, artifact } = await provider.getProtocolContractArtifact(name);
+          await this.contractStore.addContractArtifact(artifact);
+          await this.contractStore.addContractInstance(instance);
+        }
+        this.logger.debug('Registered protocol contracts in shared contract store');
       }
-      sessions.set(sessionId, await TXESession.init(this.protocolContracts));
+      sessions.set(sessionId, await TXESession.init(this.contractStore));
     }
 
     switch (functionName) {
-      case 'txeDeploy': {
+      case 'aztec_txe_deploy': {
         await this.#processDeployInputs(callData);
         break;
       }
-      case 'txeAddAccount': {
+      case 'aztec_txe_addAccount': {
         await this.#processAddAccountInputs(callData);
         break;
       }

package/src/oracle/interfaces.ts

@@ -24,18 +24,18 @@ import type { UInt64 } from '@aztec/stdlib/types';
 export interface IAvmExecutionOracle {
   isAvm: true;
 
-  avmOpcodeAddress(): Promise<AztecAddress>;
-  avmOpcodeSender(): Promise<AztecAddress>;
-  avmOpcodeBlockNumber(): Promise<BlockNumber>;
-  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>;
+  address(): Promise<AztecAddress>;
+  sender(): Promise<AztecAddress>;
+  blockNumber(): Promise<BlockNumber>;
+  timestamp(): Promise<bigint>;
+  isStaticCall(): Promise<boolean>;
+  chainId(): Promise<Fr>;
+  version(): Promise<Fr>;
+  emitNullifier(nullifier: Fr): Promise<void>;
+  emitNoteHash(noteHash: Fr): Promise<void>;
+  nullifierExists(siloedNullifier: Fr): Promise<boolean>;
+  storageWrite(slot: Fr, value: Fr): Promise<void>;
+  storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
 }
 
 /**
@@ -44,43 +44,44 @@ export interface IAvmExecutionOracle {
 export interface ITxeExecutionOracle {
   isTxe: true;
 
-  txeGetDefaultAddress(): AztecAddress;
-  txeGetNextBlockNumber(): Promise<BlockNumber>;
-  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<{
+  getDefaultAddress(): AztecAddress;
+  getNextBlockNumber(): Promise<BlockNumber>;
+  getNextBlockTimestamp(): Promise<UInt64>;
+  advanceBlocksBy(blocks: number): Promise<void>;
+  advanceTimestampBy(duration: UInt64): void;
+  deploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
+  createAccount(secret: Fr): Promise<CompleteAddress>;
+  addAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<CompleteAddress>;
+  addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+  getLastBlockTimestamp(): Promise<bigint>;
+  getLastTxEffects(): Promise<{
     txHash: TxHash;
     noteHashes: Fr[];
     nullifiers: Fr[];
   }>;
-  txeGetPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
-  txePrivateCallNewFlow(
+  getPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
+  privateCallNewFlow(
     from: AztecAddress,
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     args: Fr[],
     argsHash: Fr,
     isStaticCall: boolean,
+    jobId: string,
   ): Promise<Fr[]>;
-  txeSimulateUtilityFunction(
+  executeUtilityFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     args: Fr[],
+    jobId: string,
   ): Promise<Fr[]>;
-  txePublicCallNewFlow(
+  publicCallNewFlow(
     from: AztecAddress,
     targetContractAddress: AztecAddress,
     calldata: Fr[],
     isStaticCall: boolean,
   ): Promise<Fr[]>;
+  // TODO(F-335): Drop this from here as it's not a real oracle handler - it's only called from
+  // RPCTranslator::txeGetPrivateEvents and never from Noir.
+  syncContractNonOracleMethod(contractAddress: AztecAddress, scope: AztecAddress, jobId: string): Promise<void>;
 }

package/src/oracle/txe_oracle_public_context.ts

@@ -3,7 +3,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import {
   MerkleTreeId,
@@ -39,57 +39,55 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     });
   }
 
-  avmOpcodeAddress(): Promise<AztecAddress> {
+  address(): Promise<AztecAddress> {
     return Promise.resolve(this.contractAddress);
   }
 
-  avmOpcodeSender(): Promise<AztecAddress> {
+  sender(): Promise<AztecAddress> {
     return Promise.resolve(AztecAddress.ZERO); // todo: change?
   }
 
-  avmOpcodeBlockNumber(): Promise<BlockNumber> {
+  blockNumber(): Promise<BlockNumber> {
     return Promise.resolve(this.globalVariables.blockNumber);
   }
 
-  avmOpcodeTimestamp(): Promise<bigint> {
+  timestamp(): Promise<bigint> {
     return Promise.resolve(this.globalVariables.timestamp);
   }
 
-  avmOpcodeIsStaticCall(): Promise<boolean> {
+  isStaticCall(): Promise<boolean> {
     return Promise.resolve(false);
   }
 
-  avmOpcodeChainId(): Promise<Fr> {
+  chainId(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.chainId);
   }
 
-  avmOpcodeVersion(): Promise<Fr> {
+  version(): Promise<Fr> {
     return Promise.resolve(this.globalVariables.version);
   }
 
-  async avmOpcodeEmitNullifier(nullifier: Fr) {
+  async emitNullifier(nullifier: Fr) {
     const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
     this.transientSiloedNullifiers.push(siloedNullifier);
   }
 
-  async avmOpcodeEmitNoteHash(noteHash: Fr) {
+  async emitNoteHash(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!);
-
+  async nullifierExists(siloedNullifier: Fr): Promise<boolean> {
     const treeIndex = (
-      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()])
+      await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()])
     )[0];
-    const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(nullifier));
+    const transientIndex = this.transientSiloedNullifiers.find(n => n.equals(siloedNullifier));
 
     return treeIndex !== undefined || transientIndex !== undefined;
   }
 
-  async avmOpcodeStorageWrite(slot: Fr, value: Fr) {
+  async storageWrite(slot: Fr, value: Fr) {
     this.logger.debug('AVM storage write', { slot, value });
 
     const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
@@ -101,8 +99,8 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
     ]);
   }
 
-  async avmOpcodeStorageRead(slot: Fr): Promise<Fr> {
-    const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
+  async storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr> {
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
 
     const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(
       MerkleTreeId.PUBLIC_DATA_TREE,
@@ -119,12 +117,12 @@ export class TXEOraclePublicContext implements IAvmExecutionOracle {
             )) as PublicDataTreeLeafPreimage
           ).leaf.value;
 
-    this.logger.debug('AVM storage read', { slot, value });
+    this.logger.debug('AVM storage read', { slot, contractAddress, value });
 
     return value;
   }
 
-  async close(): Promise<L2BlockNew> {
+  async close(): Promise<L2Block> {
     this.logger.debug('Exiting Public Context, building block with collected side effects', {
       blockNumber: this.globalVariables.blockNumber,
     });