@aztec/txe 0.46.7 → 0.47.1

package/src/oracle/txe_oracle.ts

@@ -1,5 +1,7 @@
 import {
   AuthWitness,
+  Event,
+  L1EventPayload,
   L1NotePayload,
   MerkleTreeId,
   Note,
@@ -7,13 +9,13 @@ import {
   NullifierMembershipWitness,
   PublicDataWitness,
   PublicDataWrite,
+  PublicExecutionRequest,
   TaggedLog,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
   CallContext,
-  FunctionData,
   Gas,
   GlobalVariables,
   Header,
@@ -23,10 +25,8 @@ import {
   type NullifierLeafPreimage,
   PUBLIC_DATA_SUBTREE_HEIGHT,
   type PUBLIC_DATA_TREE_HEIGHT,
-  PrivateCallStackItem,
   PrivateCircuitPublicInputs,
   PrivateContextInputs,
-  PublicCallRequest,
   PublicDataTreeLeaf,
   type PublicDataTreeLeafPreimage,
   TxContext,
@@ -38,6 +38,7 @@ import { Aes128, Schnorr } from '@aztec/circuits.js/barretenberg';
 import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
 import {
   type ContractArtifact,
+  EventSelector,
   type FunctionAbi,
   FunctionSelector,
   type NoteSelector,
@@ -523,6 +524,7 @@ export class TXE implements TypedOracle {
     noteTypeId: NoteSelector,
     ovKeys: KeyValidationRequest,
     ivpkM: Point,
+    recipient: AztecAddress,
     preimage: Fr[],
   ): Buffer {
     const note = new Note(preimage);
@@ -531,8 +533,6 @@ export class TXE implements TypedOracle {
 
     const ephSk = GrumpkinScalar.random();
 
-    const recipient = AztecAddress.random();
-
     return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
@@ -551,7 +551,7 @@ export class TXE implements TypedOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PrivateCallStackItem> {
+  ) {
     this.logger.verbose(
       `Executing external function ${targetContractAddress}:${functionSelector}(${await this.getDebugFunctionName(
         targetContractAddress,
@@ -607,13 +607,9 @@ export class TXE implements TypedOracle {
         appCircuitName: 'noname',
       } satisfies CircuitWitnessGenerationStats);
 
-      const callStackItem = new PrivateCallStackItem(
-        targetContractAddress,
-        new FunctionData(functionSelector, true),
-        publicInputs,
-      );
       // Apply side effects
-      this.sideEffectsCounter = publicInputs.endSideEffectCounter.toNumber();
+      const endSideEffectCounter = publicInputs.endSideEffectCounter;
+      this.sideEffectsCounter = endSideEffectCounter.toNumber();
 
       await this.addNullifiers(
         targetContractAddress,
@@ -625,7 +621,7 @@ export class TXE implements TypedOracle {
         publicInputs.noteHashes.filter(noteHash => !noteHash.isEmpty()).map(noteHash => noteHash.value),
       );
 
-      return callStackItem;
+      return { endSideEffectCounter, returnsHash: publicInputs.returnsHash };
     } finally {
       this.setContractAddress(currentContractAddress);
       this.setMsgSender(currentMessageSender);
@@ -680,12 +676,7 @@ export class TXE implements TypedOracle {
     return `${artifact.name}:${f.name}`;
   }
 
-  async executePublicFunction(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    args: Fr[],
-    callContext: CallContext,
-  ) {
+  async executePublicFunction(targetContractAddress: AztecAddress, args: Fr[], callContext: CallContext) {
     const header = Header.empty();
     header.state = await this.trees.getStateReference(true);
     header.globalVariables.blockNumber = new Fr(await this.getBlockNumber());
@@ -707,12 +698,7 @@ export class TXE implements TypedOracle {
       new WorldStateDB(this.trees.asLatest()),
       header,
     );
-    const execution = {
-      contractAddress: targetContractAddress,
-      functionSelector,
-      args,
-      callContext,
-    };
+    const execution = new PublicExecutionRequest(targetContractAddress, callContext, args);
 
     return executor.simulate(
       execution,
@@ -746,12 +732,7 @@ export class TXE implements TypedOracle {
     callContext.isStaticCall = isStaticCall;
     callContext.isDelegateCall = isDelegateCall;
 
-    const executionResult = await this.executePublicFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      callContext,
-    );
+    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
 
     // Apply side effects
     if (!executionResult.reverted) {
@@ -768,7 +749,7 @@ export class TXE implements TypedOracle {
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
-    sideEffectCounter: number,
+    _sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
   ): Promise<Fr[]> {
@@ -789,12 +770,7 @@ export class TXE implements TypedOracle {
 
     const args = this.packedValuesCache.unpack(argsHash);
 
-    const executionResult = await this.executePublicFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      callContext,
-    );
+    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
 
     // Apply side effects
     this.sideEffectsCounter = executionResult.endSideEffectCounter.toNumber();
@@ -809,10 +785,10 @@ export class TXE implements TypedOracle {
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
-    sideEffectCounter: number,
+    _sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
+  ) {
     // Store and modify env
     const currentContractAddress = AztecAddress.fromField(this.contractAddress);
     const currentMessageSender = AztecAddress.fromField(this.msgSender);
@@ -830,47 +806,26 @@ export class TXE implements TypedOracle {
 
     const args = this.packedValuesCache.unpack(argsHash);
 
-    const executionResult = await this.executePublicFunction(
-      targetContractAddress,
-      functionSelector,
-      args,
-      callContext,
-    );
+    const executionResult = await this.executePublicFunction(targetContractAddress, args, callContext);
 
     // Apply side effects
     this.sideEffectsCounter += executionResult.endSideEffectCounter.toNumber();
     this.setContractAddress(currentContractAddress);
     this.setMsgSender(currentMessageSender);
     this.setFunctionSelector(currentFunctionSelector);
-
-    const parentCallContext = CallContext.empty();
-    parentCallContext.msgSender = currentMessageSender;
-    parentCallContext.functionSelector = currentFunctionSelector;
-    parentCallContext.storageContractAddress = currentContractAddress;
-    parentCallContext.isStaticCall = isStaticCall;
-    parentCallContext.isDelegateCall = isDelegateCall;
-
-    return PublicCallRequest.from({
-      parentCallContext,
-      contractAddress: targetContractAddress,
-      functionSelector,
-      callContext,
-      sideEffectCounter,
-      args,
-    });
   }
 
-  setPublicTeardownFunctionCall(
+  async setPublicTeardownFunctionCall(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ): Promise<PublicCallRequest> {
+  ) {
     // Definitely not right, in that the teardown should always be last.
     // But useful for executing flows.
-    return this.enqueuePublicFunctionCall(
+    await this.enqueuePublicFunctionCall(
       targetContractAddress,
       functionSelector,
       argsHash,
@@ -899,13 +854,20 @@ export class TXE implements TypedOracle {
   }
 
   computeEncryptedEventLog(
-    _contractAddress: AztecAddress,
-    _randomness: Fr,
-    _eventTypeId: Fr,
-    _ovKeys: KeyValidationRequest,
-    _ivpkM: Point,
-    _preimage: Fr[],
+    contractAddress: AztecAddress,
+    randomness: Fr,
+    eventTypeId: Fr,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
+    recipient: AztecAddress,
+    preimage: Fr[],
   ): Buffer {
-    throw new Error('Method not implemented.');
+    const event = new Event(preimage);
+    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, EventSelector.fromField(eventTypeId));
+    const taggedEvent = new TaggedLog(l1EventPayload);
+
+    const ephSk = GrumpkinScalar.random();
+
+    return taggedEvent.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 }

package/src/txe_service/txe_service.ts

@@ -1,3 +1,4 @@
+import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
 import { L2Block, MerkleTreeId, PublicDataWrite } from '@aztec/circuit-types';
 import {
   Fr,
@@ -7,10 +8,11 @@ import {
   PUBLIC_DATA_SUBTREE_HEIGHT,
   Point,
   PublicDataTreeLeaf,
+  computePartialAddress,
   getContractInstanceFromDeployParams,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
-import { NoteSelector } from '@aztec/foundation/abi';
+import { type ContractArtifact, NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Logger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
@@ -92,27 +94,22 @@ export class TXEService {
   }
 
   async deploy(
-    path: ForeignCallArray,
+    artifact: ContractArtifact,
     initializer: ForeignCallArray,
     _length: ForeignCallSingle,
     args: ForeignCallArray,
     publicKeysHash: ForeignCallSingle,
   ) {
-    const pathStr = fromArray(path)
-      .map(char => String.fromCharCode(char.toNumber()))
-      .join('');
     const initializerStr = fromArray(initializer)
       .map(char => String.fromCharCode(char.toNumber()))
       .join('');
     const decodedArgs = fromArray(args);
     const publicKeysHashFr = fromSingle(publicKeysHash);
     this.logger.debug(
-      `Deploy ${pathStr} with initializer ${initializerStr}(${decodedArgs}) and public keys hash ${publicKeysHashFr}`,
+      `Deploy ${artifact.name} with initializer ${initializerStr}(${decodedArgs}) and public keys hash ${publicKeysHashFr}`,
     );
-    const contractModule = await import(pathStr);
-    // Hacky way of getting the class, the name of the Artifact is always longer
-    const contractClass = contractModule[Object.keys(contractModule).sort((a, b) => a.length - b.length)[0]];
-    const instance = getContractInstanceFromDeployParams(contractClass.artifact, {
+
+    const instance = getContractInstanceFromDeployParams(artifact, {
       constructorArgs: decodedArgs,
       skipArgsDecoding: true,
       salt: Fr.ONE,
@@ -121,9 +118,9 @@ export class TXEService {
       deployer: AztecAddress.ZERO,
     });
 
-    this.logger.debug(`Deployed ${contractClass.artifact.name} at ${instance.address}`);
+    this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
     await (this.typedOracle as TXE).addContractInstance(instance);
-    await (this.typedOracle as TXE).addContractArtifact(contractClass.artifact);
+    await (this.typedOracle as TXE).addContractArtifact(artifact);
     return toForeignCallResult([
       toArray([
         instance.salt,
@@ -171,9 +168,26 @@ export class TXEService {
     ]);
   }
 
-  async addAccount(secret: ForeignCallSingle, partialAddress: ForeignCallSingle) {
+  async addAccount(secret: ForeignCallSingle) {
+    const keys = (this.typedOracle as TXE).deriveKeys(fromSingle(secret));
+    const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
+    const hash = keys.publicKeys.hash();
+    const artifact = SchnorrAccountContractArtifact;
+    const instance = getContractInstanceFromDeployParams(artifact, {
+      constructorArgs: args,
+      skipArgsDecoding: true,
+      salt: Fr.ONE,
+      publicKeysHash: hash,
+      constructorArtifact: 'constructor',
+      deployer: AztecAddress.ZERO,
+    });
+
+    this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
+    await (this.typedOracle as TXE).addContractInstance(instance);
+    await (this.typedOracle as TXE).addContractArtifact(artifact);
+
     const keyStore = (this.typedOracle as TXE).getKeyStore();
-    const completeAddress = await keyStore.addAccount(fromSingle(secret), fromSingle(partialAddress));
+    const completeAddress = await keyStore.addAccount(fromSingle(secret), computePartialAddress(instance));
     const accountStore = (this.typedOracle as TXE).getTXEDatabase();
     await accountStore.setAccount(completeAddress.address, completeAddress);
     this.logger.debug(`Created account ${completeAddress.address}`);
@@ -578,6 +592,7 @@ export class TXEService {
     ivpkMX: ForeignCallSingle,
     ivpkMY: ForeignCallSingle,
     ivpkMIsInfinite: ForeignCallSingle,
+    recipient: ForeignCallSingle,
     preimage: ForeignCallArray,
   ) {
     const ovpkM = new Point(fromSingle(ovpkMX), fromSingle(ovpkMY), !fromSingle(ovpkMIsInfinite).isZero());
@@ -589,6 +604,7 @@ export class TXEService {
       NoteSelector.fromField(Fr.fromString(fromSingle(noteTypeId).toString())),
       ovKeys,
       ivpkM,
+      AztecAddress.fromString(fromSingle(recipient).toString()),
       fromArray(preimage),
     );
     const bytes: Fr[] = [];
@@ -636,7 +652,7 @@ export class TXEService {
       fromSingle(isStaticCall).toBool(),
       fromSingle(isDelegateCall).toBool(),
     );
-    return toForeignCallResult([toArray(result.toFields())]);
+    return toForeignCallResult([toArray([result.endSideEffectCounter, result.returnsHash])]);
   }
 
   async getNullifierMembershipWitness(blockNumber: ForeignCallSingle, nullifier: ForeignCallSingle) {
@@ -665,7 +681,7 @@ export class TXEService {
     isStaticCall: ForeignCallSingle,
     isDelegateCall: ForeignCallSingle,
   ) {
-    const publicCallRequest = await this.typedOracle.enqueuePublicFunctionCall(
+    await this.typedOracle.enqueuePublicFunctionCall(
       fromSingle(targetContractAddress),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromSingle(argsHash),
@@ -673,14 +689,7 @@ export class TXEService {
       fromSingle(isStaticCall).toBool(),
       fromSingle(isDelegateCall).toBool(),
     );
-    const fields = [
-      publicCallRequest.contractAddress.toField(),
-      publicCallRequest.functionSelector.toField(),
-      ...publicCallRequest.callContext.toFields(),
-      fromSingle(sideEffectCounter),
-      publicCallRequest.getArgsHash(),
-    ];
-    return toForeignCallResult([toArray(fields)]);
+    return toForeignCallResult([]);
   }
 
   public async setPublicTeardownFunctionCall(
@@ -691,7 +700,7 @@ export class TXEService {
     isStaticCall: ForeignCallSingle,
     isDelegateCall: ForeignCallSingle,
   ) {
-    const publicTeardownCallRequest = await this.typedOracle.setPublicTeardownFunctionCall(
+    await this.typedOracle.setPublicTeardownFunctionCall(
       fromSingle(targetContractAddress),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromSingle(argsHash),
@@ -699,16 +708,7 @@ export class TXEService {
       fromSingle(isStaticCall).toBool(),
       fromSingle(isDelegateCall).toBool(),
     );
-
-    const fields = [
-      publicTeardownCallRequest.contractAddress.toField(),
-      publicTeardownCallRequest.functionSelector.toField(),
-      ...publicTeardownCallRequest.callContext.toFields(),
-      fromSingle(sideEffectCounter),
-      publicTeardownCallRequest.getArgsHash(),
-    ];
-
-    return toForeignCallResult([toArray(fields)]);
+    return toForeignCallResult([]);
   }
 
   async getChainId() {