@aztec/txe 0.59.0 → 0.61.0

package/src/txe_service/txe_service.ts

@@ -1,5 +1,5 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { L2Block, MerkleTreeId, PublicDataWrite } from '@aztec/circuit-types';
+import { L2Block, MerkleTreeId, PublicDataWrite, SimulationError } from '@aztec/circuit-types';
 import {
   Fr,
   FunctionSelector,
@@ -17,6 +17,7 @@ import { type Logger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/utils';
 import { getCanonicalProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
+import { enrichPublicSimulationError } from '@aztec/pxe';
 import { ExecutionNoteCache, PackedValuesCache, type TypedOracle } from '@aztec/simulator';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
@@ -117,7 +118,7 @@ export class TXEService {
       skipArgsDecoding: true,
       salt: Fr.ONE,
       // TODO: Modify this to allow for passing public keys.
-      publicKeys: PublicKeys.empty(),
+      publicKeys: PublicKeys.default(),
       constructorArtifact: initializerStr ? initializerStr : undefined,
       deployer: AztecAddress.ZERO,
     });
@@ -200,16 +201,6 @@ export class TXEService {
     ]);
   }
 
-  setMsgSender(msgSender: ForeignCallSingle) {
-    (this.typedOracle as TXE).setMsgSender(fromSingle(msgSender));
-    return toForeignCallResult([]);
-  }
-
-  getMsgSender() {
-    const msgSender = (this.typedOracle as TXE).getMsgSender();
-    return toForeignCallResult([toSingle(msgSender)]);
-  }
-
   getSideEffectsCounter() {
     const counter = (this.typedOracle as TXE).getSideEffectsCounter();
     return toForeignCallResult([toSingle(new Fr(counter))]);
@@ -227,14 +218,9 @@ export class TXEService {
     args: ForeignCallArray,
   ) {
     const parsedAddress = fromSingle(address);
-    const parsedSelector = FunctionSelector.fromField(fromSingle(functionSelector));
-    const result = await (this.typedOracle as TXE).avmOpcodeCall(
-      parsedAddress,
-      parsedSelector,
-      fromArray(args),
-      false,
-      false,
-    );
+    const parsedSelector = fromSingle(functionSelector);
+    const extendedArgs = [parsedSelector, ...fromArray(args)];
+    const result = await (this.typedOracle as TXE).avmOpcodeCall(parsedAddress, extendedArgs, false);
     if (!result.reverted) {
       throw new ExpectedFailureError('Public call did not revert');
     }
@@ -248,7 +234,6 @@ export class TXEService {
     argsHash: ForeignCallSingle,
     sideEffectCounter: ForeignCallSingle,
     isStaticCall: ForeignCallSingle,
-    isDelegateCall: ForeignCallSingle,
   ) {
     try {
       await this.typedOracle.callPrivateFunction(
@@ -257,7 +242,6 @@ export class TXEService {
         fromSingle(argsHash),
         fromSingle(sideEffectCounter).toNumber(),
         fromSingle(isStaticCall).toBool(),
-        fromSingle(isDelegateCall).toBool(),
       );
       throw new ExpectedFailureError('Private call did not fail');
     } catch (e) {
@@ -268,21 +252,6 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  setFunctionSelector(functionSelector: ForeignCallSingle) {
-    (this.typedOracle as TXE).setFunctionSelector(FunctionSelector.fromField(fromSingle(functionSelector)));
-    return toForeignCallResult([]);
-  }
-
-  setCalldata(_length: ForeignCallSingle, calldata: ForeignCallArray) {
-    (this.typedOracle as TXE).setCalldata(fromArray(calldata));
-    return toForeignCallResult([]);
-  }
-
-  getFunctionSelector() {
-    const functionSelector = (this.typedOracle as TXE).getFunctionSelector();
-    return toForeignCallResult([toSingle(functionSelector.toField())]);
-  }
-
   // PXE oracles
 
   getRandomField() {
@@ -299,41 +268,6 @@ export class TXEService {
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
-  async avmOpcodeAddress() {
-    const contractAddress = await this.typedOracle.getContractAddress();
-    return toForeignCallResult([toSingle(contractAddress.toField())]);
-  }
-
-  async avmOpcodeBlockNumber() {
-    const blockNumber = await this.typedOracle.getBlockNumber();
-    return toForeignCallResult([toSingle(new Fr(blockNumber))]);
-  }
-
-  avmOpcodeFunctionSelector() {
-    const functionSelector = (this.typedOracle as TXE).getFunctionSelector();
-    return toForeignCallResult([toSingle(functionSelector.toField())]);
-  }
-
-  setIsStaticCall(isStaticCall: ForeignCallSingle) {
-    (this.typedOracle as TXE).setIsStaticCall(fromSingle(isStaticCall).toBool());
-    return toForeignCallResult([]);
-  }
-
-  avmOpcodeIsStaticCall() {
-    const isStaticCall = (this.typedOracle as TXE).getIsStaticCall();
-    return toForeignCallResult([toSingle(new Fr(isStaticCall ? 1 : 0))]);
-  }
-
-  async avmOpcodeChainId() {
-    const chainId = await (this.typedOracle as TXE).getChainId();
-    return toForeignCallResult([toSingle(chainId)]);
-  }
-
-  async avmOpcodeVersion() {
-    const version = await (this.typedOracle as TXE).getVersion();
-    return toForeignCallResult([toSingle(version)]);
-  }
-
   async packArgumentsArray(args: ForeignCallArray) {
     const packed = await this.typedOracle.packArgumentsArray(fromArray(args));
     return toForeignCallResult([toSingle(packed)]);
@@ -514,101 +448,6 @@ export class TXEService {
     ]);
   }
 
-  async avmOpcodeGetContractInstance(address: ForeignCallSingle) {
-    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
-    return toForeignCallResult([
-      toArray([
-        // AVM requires an extra boolean indicating the instance was found
-        new Fr(1),
-        instance.salt,
-        instance.deployer,
-        instance.contractClassId,
-        instance.initializationHash,
-        ...instance.publicKeys.toFields(),
-      ]),
-    ]);
-  }
-
-  avmOpcodeSender() {
-    const sender = (this.typedOracle as TXE).getMsgSender();
-    return toForeignCallResult([toSingle(sender)]);
-  }
-
-  async avmOpcodeEmitNullifier(nullifier: ForeignCallSingle) {
-    await (this.typedOracle as TXE).avmOpcodeEmitNullifier(fromSingle(nullifier));
-    return toForeignCallResult([]);
-  }
-
-  async avmOpcodeEmitNoteHash(noteHash: ForeignCallSingle) {
-    await (this.typedOracle as TXE).avmOpcodeEmitNoteHash(fromSingle(noteHash));
-    return toForeignCallResult([]);
-  }
-
-  async avmOpcodeNullifierExists(innerNullifier: ForeignCallSingle, targetAddress: ForeignCallSingle) {
-    const exists = await (this.typedOracle as TXE).avmOpcodeNullifierExists(
-      fromSingle(innerNullifier),
-      AztecAddress.fromField(fromSingle(targetAddress)),
-    );
-    return toForeignCallResult([toSingle(new Fr(exists))]);
-  }
-
-  async avmOpcodeCall(
-    _gas: ForeignCallArray,
-    address: ForeignCallSingle,
-    _length: ForeignCallSingle,
-    args: ForeignCallArray,
-    functionSelector: ForeignCallSingle,
-  ) {
-    const result = await (this.typedOracle as TXE).avmOpcodeCall(
-      fromSingle(address),
-      FunctionSelector.fromField(fromSingle(functionSelector)),
-      fromArray(args),
-      /* isStaticCall */ false,
-      /* isDelegateCall */ false,
-    );
-
-    return toForeignCallResult([toArray(result.returnValues), toSingle(new Fr(1))]);
-  }
-
-  async avmOpcodeStaticCall(
-    _gas: ForeignCallArray,
-    address: ForeignCallSingle,
-    _length: ForeignCallSingle,
-    args: ForeignCallArray,
-    functionSelector: ForeignCallSingle,
-  ) {
-    const result = await (this.typedOracle as TXE).avmOpcodeCall(
-      fromSingle(address),
-      FunctionSelector.fromField(fromSingle(functionSelector)),
-      fromArray(args),
-      /* isStaticCall */ true,
-      /* isDelegateCall */ false,
-    );
-
-    return toForeignCallResult([toArray(result.returnValues), toSingle(new Fr(1))]);
-  }
-
-  async avmOpcodeStorageRead(slot: ForeignCallSingle) {
-    const value = await (this.typedOracle as TXE).avmOpcodeStorageRead(fromSingle(slot));
-    return toForeignCallResult([toSingle(value)]);
-  }
-
-  async avmOpcodeStorageWrite(slot: ForeignCallSingle, value: ForeignCallSingle) {
-    await this.typedOracle.storageWrite(fromSingle(slot), [fromSingle(value)]);
-    return toForeignCallResult([]);
-  }
-
-  //unconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}
-  avmOpcodeCalldataCopy(cdOffsetInput: ForeignCallSingle, copySizeInput: ForeignCallSingle) {
-    const cdOffset = fromSingle(cdOffsetInput).toNumber();
-    const copySize = fromSingle(copySizeInput).toNumber();
-
-    const calldata = (this.typedOracle as TXE).getCalldata();
-    const calldataSlice = calldata.slice(cdOffset, cdOffset + copySize);
-
-    return toForeignCallResult([toArray(calldataSlice)]);
-  }
-
   async getPublicKeysAndPartialAddress(address: ForeignCallSingle) {
     const parsedAddress = AztecAddress.fromField(fromSingle(address));
     const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
@@ -650,7 +489,6 @@ export class TXEService {
     argsHash: ForeignCallSingle,
     sideEffectCounter: ForeignCallSingle,
     isStaticCall: ForeignCallSingle,
-    isDelegateCall: ForeignCallSingle,
   ) {
     const result = await this.typedOracle.callPrivateFunction(
       fromSingle(targetContractAddress),
@@ -658,7 +496,6 @@ export class TXEService {
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
       fromSingle(isStaticCall).toBool(),
-      fromSingle(isDelegateCall).toBool(),
     );
     return toForeignCallResult([toArray([result.endSideEffectCounter, result.returnsHash])]);
   }
@@ -687,7 +524,6 @@ export class TXEService {
     argsHash: ForeignCallSingle,
     sideEffectCounter: ForeignCallSingle,
     isStaticCall: ForeignCallSingle,
-    isDelegateCall: ForeignCallSingle,
   ) {
     const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(
       fromSingle(targetContractAddress),
@@ -695,7 +531,6 @@ export class TXEService {
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
       fromSingle(isStaticCall).toBool(),
-      fromSingle(isDelegateCall).toBool(),
     );
     return toForeignCallResult([toSingle(newArgsHash)]);
   }
@@ -706,7 +541,6 @@ export class TXEService {
     argsHash: ForeignCallSingle,
     sideEffectCounter: ForeignCallSingle,
     isStaticCall: ForeignCallSingle,
-    isDelegateCall: ForeignCallSingle,
   ) {
     const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(
       fromSingle(targetContractAddress),
@@ -714,7 +548,6 @@ export class TXEService {
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
       fromSingle(isStaticCall).toBool(),
-      fromSingle(isDelegateCall).toBool(),
     );
     return toForeignCallResult([toSingle(newArgsHash)]);
   }
@@ -767,8 +600,189 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  async getAppTaggingSecret(sender: ForeignCallSingle, recipient: ForeignCallSingle) {
+    const secret = await this.typedOracle.getAppTaggingSecret(
+      AztecAddress.fromField(fromSingle(sender)),
+      AztecAddress.fromField(fromSingle(recipient)),
+    );
+    return toForeignCallResult([toArray(secret.toFields())]);
+  }
+
+  async getAppTaggingSecretsForSenders(recipient: ForeignCallSingle) {
+    const secrets = await this.typedOracle.getAppTaggingSecretsForSenders(
+      AztecAddress.fromField(fromSingle(recipient)),
+    );
+    return toForeignCallResult([toArray(secrets.flatMap(secret => secret.toFields()))]);
+  }
+
+  // AVM opcodes
+
   avmOpcodeEmitUnencryptedLog(_message: ForeignCallArray) {
     // TODO(#8811): Implement
     return toForeignCallResult([]);
   }
+
+  async avmOpcodeStorageRead(slot: ForeignCallSingle) {
+    const value = await (this.typedOracle as TXE).avmOpcodeStorageRead(fromSingle(slot));
+    return toForeignCallResult([toSingle(value)]);
+  }
+
+  async avmOpcodeStorageWrite(slot: ForeignCallSingle, value: ForeignCallSingle) {
+    await this.typedOracle.storageWrite(fromSingle(slot), [fromSingle(value)]);
+    return toForeignCallResult([]);
+  }
+
+  async avmOpcodeGetContractInstanceDeployer(address: ForeignCallSingle) {
+    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    return toForeignCallResult([
+      toSingle(instance.deployer),
+      // AVM requires an extra boolean indicating the instance was found
+      toSingle(new Fr(1)),
+    ]);
+  }
+
+  async avmOpcodeGetContractInstanceClassId(address: ForeignCallSingle) {
+    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    return toForeignCallResult([
+      toSingle(instance.contractClassId),
+      // AVM requires an extra boolean indicating the instance was found
+      toSingle(new Fr(1)),
+    ]);
+  }
+
+  async avmOpcodeGetContractInstanceInitializationHash(address: ForeignCallSingle) {
+    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    return toForeignCallResult([
+      toSingle(instance.initializationHash),
+      // AVM requires an extra boolean indicating the instance was found
+      toSingle(new Fr(1)),
+    ]);
+  }
+
+  avmOpcodeSender() {
+    const sender = (this.typedOracle as TXE).getMsgSender();
+    return toForeignCallResult([toSingle(sender)]);
+  }
+
+  async avmOpcodeEmitNullifier(nullifier: ForeignCallSingle) {
+    await (this.typedOracle as TXE).avmOpcodeEmitNullifier(fromSingle(nullifier));
+    return toForeignCallResult([]);
+  }
+
+  async avmOpcodeEmitNoteHash(noteHash: ForeignCallSingle) {
+    await (this.typedOracle as TXE).avmOpcodeEmitNoteHash(fromSingle(noteHash));
+    return toForeignCallResult([]);
+  }
+
+  async avmOpcodeNullifierExists(innerNullifier: ForeignCallSingle, targetAddress: ForeignCallSingle) {
+    const exists = await (this.typedOracle as TXE).avmOpcodeNullifierExists(
+      fromSingle(innerNullifier),
+      AztecAddress.fromField(fromSingle(targetAddress)),
+    );
+    return toForeignCallResult([toSingle(new Fr(exists))]);
+  }
+
+  async avmOpcodeAddress() {
+    const contractAddress = await this.typedOracle.getContractAddress();
+    return toForeignCallResult([toSingle(contractAddress.toField())]);
+  }
+
+  async avmOpcodeBlockNumber() {
+    const blockNumber = await this.typedOracle.getBlockNumber();
+    return toForeignCallResult([toSingle(new Fr(blockNumber))]);
+  }
+
+  avmOpcodeFunctionSelector() {
+    const functionSelector = (this.typedOracle as TXE).getFunctionSelector();
+    return toForeignCallResult([toSingle(functionSelector.toField())]);
+  }
+
+  avmOpcodeIsStaticCall() {
+    const isStaticCall = (this.typedOracle as TXE).getIsStaticCall();
+    return toForeignCallResult([toSingle(new Fr(isStaticCall ? 1 : 0))]);
+  }
+
+  async avmOpcodeChainId() {
+    const chainId = await (this.typedOracle as TXE).getChainId();
+    return toForeignCallResult([toSingle(chainId)]);
+  }
+
+  async avmOpcodeVersion() {
+    const version = await (this.typedOracle as TXE).getVersion();
+    return toForeignCallResult([toSingle(version)]);
+  }
+
+  avmOpcodeReturndataSize() {
+    const size = (this.typedOracle as TXE).avmOpcodeReturndataSize();
+    return toForeignCallResult([toSingle(new Fr(size))]);
+  }
+
+  avmOpcodeReturndataCopy(rdOffset: ForeignCallSingle, copySize: ForeignCallSingle) {
+    const returndata = (this.typedOracle as TXE).avmOpcodeReturndataCopy(
+      fromSingle(rdOffset).toNumber(),
+      fromSingle(copySize).toNumber(),
+    );
+    // This is a slice, so we need to return the length as well.
+    return toForeignCallResult([toSingle(new Fr(returndata.length)), toArray(returndata)]);
+  }
+
+  async avmOpcodeCall(
+    _gas: ForeignCallArray,
+    address: ForeignCallSingle,
+    _length: ForeignCallSingle,
+    args: ForeignCallArray,
+  ) {
+    const result = await (this.typedOracle as TXE).avmOpcodeCall(
+      fromSingle(address),
+      fromArray(args),
+      /* isStaticCall */ false,
+    );
+
+    // Poor man's revert handling
+    if (result.reverted) {
+      if (result.revertReason && result.revertReason instanceof SimulationError) {
+        await enrichPublicSimulationError(
+          result.revertReason,
+          (this.typedOracle as TXE).getContractDataOracle(),
+          (this.typedOracle as TXE).getTXEDatabase(),
+          this.logger,
+        );
+        throw new Error(result.revertReason.message);
+      } else {
+        throw new Error(`Public function call reverted: ${result.revertReason}`);
+      }
+    }
+
+    return toForeignCallResult([toSingle(new Fr(!result.reverted))]);
+  }
+
+  async avmOpcodeStaticCall(
+    _gas: ForeignCallArray,
+    address: ForeignCallSingle,
+    _length: ForeignCallSingle,
+    args: ForeignCallArray,
+  ) {
+    const result = await (this.typedOracle as TXE).avmOpcodeCall(
+      fromSingle(address),
+      fromArray(args),
+      /* isStaticCall */ true,
+    );
+
+    // Poor man's revert handling
+    if (result.reverted) {
+      if (result.revertReason && result.revertReason instanceof SimulationError) {
+        await enrichPublicSimulationError(
+          result.revertReason,
+          (this.typedOracle as TXE).getContractDataOracle(),
+          (this.typedOracle as TXE).getTXEDatabase(),
+          this.logger,
+        );
+        throw new Error(result.revertReason.message);
+      } else {
+        throw new Error(`Public function call reverted: ${result.revertReason}`);
+      }
+    }
+
+    return toForeignCallResult([toSingle(new Fr(!result.reverted))]);
+  }
 }