@aztec/txe 0.62.0 → 0.63.0

package/src/txe_service/txe_service.ts

@@ -1,5 +1,5 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { L2Block, MerkleTreeId, PublicDataWrite, SimulationError } from '@aztec/circuit-types';
+import { L2Block, MerkleTreeId, SimulationError } from '@aztec/circuit-types';
 import {
   Fr,
   FunctionSelector,
@@ -26,6 +26,7 @@ import { TXE } from '../oracle/txe_oracle.js';
 import {
   type ForeignCallArray,
   type ForeignCallSingle,
+  addressFromSingle,
   fromArray,
   fromSingle,
   toArray,
@@ -87,7 +88,7 @@ export class TXEService {
   }
 
   setContractAddress(address: ForeignCallSingle) {
-    const typedAddress = AztecAddress.fromField(fromSingle(address));
+    const typedAddress = addressFromSingle(address);
     (this.typedOracle as TXE).setContractAddress(typedAddress);
     return toForeignCallResult([]);
   }
@@ -129,7 +130,7 @@ export class TXEService {
     return toForeignCallResult([
       toArray([
         instance.salt,
-        instance.deployer,
+        instance.deployer.toField(),
         instance.contractClassId,
         instance.initializationHash,
         ...instance.publicKeys.toFields(),
@@ -145,20 +146,20 @@ export class TXEService {
     const trees = (this.typedOracle as TXE).getTrees();
     const startStorageSlotFr = fromSingle(startStorageSlot);
     const valuesFr = fromArray(values);
-    const contractAddressFr = fromSingle(contractAddress);
+    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 PublicDataWrite(computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
+      return new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
     });
     await db.batchInsert(
       MerkleTreeId.PUBLIC_DATA_TREE,
-      publicDataWrites.map(write => new PublicDataTreeLeaf(write.leafIndex, write.newValue).toBuffer()),
+      publicDataWrites.map(write => write.toBuffer()),
       PUBLIC_DATA_SUBTREE_HEIGHT,
     );
-    return toForeignCallResult([toArray(publicDataWrites.map(write => write.newValue))]);
+    return toForeignCallResult([toArray(publicDataWrites.map(write => write.value))]);
   }
 
   async createAccount() {
@@ -207,7 +208,7 @@ export class TXEService {
   }
 
   async addAuthWitness(address: ForeignCallSingle, messageHash: ForeignCallSingle) {
-    await (this.typedOracle as TXE).addAuthWitness(fromSingle(address), fromSingle(messageHash));
+    await (this.typedOracle as TXE).addAuthWitness(addressFromSingle(address), fromSingle(messageHash));
     return toForeignCallResult([]);
   }
 
@@ -217,7 +218,7 @@ export class TXEService {
     _length: ForeignCallSingle,
     args: ForeignCallArray,
   ) {
-    const parsedAddress = fromSingle(address);
+    const parsedAddress = addressFromSingle(address);
     const parsedSelector = fromSingle(functionSelector);
     const extendedArgs = [parsedSelector, ...fromArray(args)];
     const result = await (this.typedOracle as TXE).avmOpcodeCall(parsedAddress, extendedArgs, false);
@@ -237,7 +238,7 @@ export class TXEService {
   ) {
     try {
       await this.typedOracle.callPrivateFunction(
-        fromSingle(targetContractAddress),
+        addressFromSingle(targetContractAddress),
         FunctionSelector.fromField(fromSingle(functionSelector)),
         fromSingle(argsHash),
         fromSingle(sideEffectCounter).toNumber(),
@@ -306,7 +307,7 @@ export class TXEService {
     numberOfElements: ForeignCallSingle,
   ) {
     const values = await this.typedOracle.storageRead(
-      fromSingle(contractAddress),
+      addressFromSingle(contractAddress),
       fromSingle(startStorageSlot),
       fromSingle(blockNumber).toNumber(),
       fromSingle(numberOfElements).toNumber(),
@@ -391,7 +392,7 @@ export class TXEService {
     ]);
 
     const returnFieldSize = fromSingle(returnSize).toNumber();
-    const returnData = [noteDatas.length, contractAddress, ...flattenData].map(v => new Fr(v));
+    const returnData = [noteDatas.length, contractAddress.toField(), ...flattenData].map(v => new Fr(v));
     if (returnData.length > returnFieldSize) {
       throw new Error(`Return data size too big. Maximum ${returnFieldSize} fields. Got ${flattenData.length}.`);
     }
@@ -436,11 +437,11 @@ export class TXEService {
   }
 
   async getContractInstance(address: ForeignCallSingle) {
-    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
     return toForeignCallResult([
       toArray([
         instance.salt,
-        instance.deployer,
+        instance.deployer.toField(),
         instance.contractClassId,
         instance.initializationHash,
         ...instance.publicKeys.toFields(),
@@ -449,7 +450,7 @@ export class TXEService {
   }
 
   async getPublicKeysAndPartialAddress(address: ForeignCallSingle) {
-    const parsedAddress = AztecAddress.fromField(fromSingle(address));
+    const parsedAddress = addressFromSingle(address);
     const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
     return toForeignCallResult([toArray([...publicKeys.toFields(), partialAddress])]);
   }
@@ -491,7 +492,7 @@ export class TXEService {
     isStaticCall: ForeignCallSingle,
   ) {
     const result = await this.typedOracle.callPrivateFunction(
-      fromSingle(targetContractAddress),
+      addressFromSingle(targetContractAddress),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
@@ -526,7 +527,7 @@ export class TXEService {
     isStaticCall: ForeignCallSingle,
   ) {
     const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(
-      fromSingle(targetContractAddress),
+      addressFromSingle(targetContractAddress),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
@@ -543,7 +544,7 @@ export class TXEService {
     isStaticCall: ForeignCallSingle,
   ) {
     const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(
-      fromSingle(targetContractAddress),
+      addressFromSingle(targetContractAddress),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromSingle(argsHash),
       fromSingle(sideEffectCounter).toNumber(),
@@ -565,12 +566,12 @@ export class TXEService {
   }
 
   async addNullifiers(contractAddress: ForeignCallSingle, _length: ForeignCallSingle, nullifiers: ForeignCallArray) {
-    await (this.typedOracle as TXE).addNullifiers(fromSingle(contractAddress), fromArray(nullifiers));
+    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(fromSingle(contractAddress), fromArray(noteHashes));
+    await (this.typedOracle as TXE).addNoteHashes(addressFromSingle(contractAddress), fromArray(noteHashes));
     return toForeignCallResult([]);
   }
 
@@ -600,19 +601,17 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  async getAppTaggingSecret(sender: ForeignCallSingle, recipient: ForeignCallSingle) {
-    const secret = await this.typedOracle.getAppTaggingSecret(
+  async getAppTaggingSecretAsSender(sender: ForeignCallSingle, recipient: ForeignCallSingle) {
+    const secret = await this.typedOracle.getAppTaggingSecretAsSender(
       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()))]);
+  async syncNotes() {
+    await this.typedOracle.syncNotes();
+    return toForeignCallResult([]);
   }
 
   // AVM opcodes
@@ -633,7 +632,7 @@ export class TXEService {
   }
 
   async avmOpcodeGetContractInstanceDeployer(address: ForeignCallSingle) {
-    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
     return toForeignCallResult([
       toSingle(instance.deployer),
       // AVM requires an extra boolean indicating the instance was found
@@ -642,7 +641,7 @@ export class TXEService {
   }
 
   async avmOpcodeGetContractInstanceClassId(address: ForeignCallSingle) {
-    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
     return toForeignCallResult([
       toSingle(instance.contractClassId),
       // AVM requires an extra boolean indicating the instance was found
@@ -651,7 +650,7 @@ export class TXEService {
   }
 
   async avmOpcodeGetContractInstanceInitializationHash(address: ForeignCallSingle) {
-    const instance = await this.typedOracle.getContractInstance(fromSingle(address));
+    const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
     return toForeignCallResult([
       toSingle(instance.initializationHash),
       // AVM requires an extra boolean indicating the instance was found
@@ -733,7 +732,7 @@ export class TXEService {
     args: ForeignCallArray,
   ) {
     const result = await (this.typedOracle as TXE).avmOpcodeCall(
-      fromSingle(address),
+      addressFromSingle(address),
       fromArray(args),
       /* isStaticCall */ false,
     );
@@ -763,7 +762,7 @@ export class TXEService {
     args: ForeignCallArray,
   ) {
     const result = await (this.typedOracle as TXE).avmOpcodeCall(
-      fromSingle(address),
+      addressFromSingle(address),
       fromArray(args),
       /* isStaticCall */ true,
     );

package/src/util/encoding.ts

@@ -1,9 +1,15 @@
+import { AztecAddress } from '@aztec/circuits.js';
+import { type ContractArtifact, ContractArtifactSchema } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 
+import { z } from 'zod';
+
 export type ForeignCallSingle = string;
 
 export type ForeignCallArray = string[];
 
+export type ForeignCallArgs = (ForeignCallSingle | ForeignCallArray | ContractArtifact)[];
+
 export type ForeignCallResult = {
   values: (ForeignCallSingle | ForeignCallArray)[];
 };
@@ -12,11 +18,15 @@ export function fromSingle(obj: ForeignCallSingle) {
   return Fr.fromBuffer(Buffer.from(obj, 'hex'));
 }
 
+export function addressFromSingle(obj: ForeignCallSingle) {
+  return new AztecAddress(fromSingle(obj));
+}
+
 export function fromArray(obj: ForeignCallArray) {
   return obj.map(str => Fr.fromBuffer(Buffer.from(str, 'hex')));
 }
 
-export function toSingle(obj: Fr) {
+export function toSingle(obj: Fr | AztecAddress) {
   return obj.toString().slice(2);
 }
 
@@ -27,3 +37,15 @@ export function toArray(objs: Fr[]) {
 export function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]) {
   return { values: obj };
 }
+
+export const ForeignCallSingleSchema = z.string();
+
+export const ForeignCallArraySchema = z.array(z.string());
+
+export const ForeignCallArgsSchema = z.array(
+  z.union([ForeignCallSingleSchema, ForeignCallArraySchema, ContractArtifactSchema]),
+);
+
+export const ForeignCallResultSchema = z.object({
+  values: z.array(z.union([ForeignCallSingleSchema, ForeignCallArraySchema])),
+});