@aztec/txe 0.80.0 → 0.82.0

package/src/txe_service/txe_service.ts

@@ -1,4 +1,4 @@
-import { type ContractInstanceWithAddress, Fr } from '@aztec/aztec.js';
+import { type ContractInstanceWithAddress, Fr, Point } from '@aztec/aztec.js';
 import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
 import type { Logger } from '@aztec/foundation/log';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
@@ -11,6 +11,7 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePartialAddress } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
+import { LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
 import { TXE } from '../oracle/txe_oracle.js';
@@ -23,9 +24,11 @@ import {
   fromArray,
   fromSingle,
   fromUintArray,
+  fromUintBoundedVec,
   toArray,
   toForeignCallResult,
   toSingle,
+  toSingleOrArray,
 } from '../util/encoding.js';
 import { ExpectedFailureError } from '../util/expected_failure_error.js';
 
@@ -260,15 +263,15 @@ export class TXEService {
     return toForeignCallResult([toArray(newValues)]);
   }
 
-  async getPublicDataTreeWitness(blockNumber: ForeignCallSingle, leafSlot: ForeignCallSingle) {
+  async getPublicDataWitness(blockNumber: ForeignCallSingle, leafSlot: ForeignCallSingle) {
     const parsedBlockNumber = fromSingle(blockNumber).toNumber();
     const parsedLeafSlot = fromSingle(leafSlot);
 
-    const witness = await this.typedOracle.getPublicDataTreeWitness(parsedBlockNumber, parsedLeafSlot);
+    const witness = await this.typedOracle.getPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
     }
-    return toForeignCallResult([toArray(witness.toFields())]);
+    return toForeignCallResult(witness.toNoirRepresentation());
   }
 
   async getNotes(
@@ -346,7 +349,7 @@ export class TXEService {
       fromSingle(noteHash),
       fromSingle(counter).toNumber(),
     );
-    return toForeignCallResult([toSingle(new Fr(0))]);
+    return toForeignCallResult([]);
   }
 
   async notifyNullifiedNote(
@@ -359,12 +362,12 @@ export class TXEService {
       fromSingle(noteHash),
       fromSingle(counter).toNumber(),
     );
-    return toForeignCallResult([toSingle(new Fr(0))]);
+    return toForeignCallResult([]);
   }
 
   async notifyCreatedNullifier(innerNullifier: ForeignCallSingle) {
     await this.typedOracle.notifyCreatedNullifier(fromSingle(innerNullifier));
-    return toForeignCallResult([toSingle(new Fr(0))]);
+    return toForeignCallResult([]);
   }
 
   async checkNullifierExists(innerNullifier: ForeignCallSingle) {
@@ -374,15 +377,15 @@ export class TXEService {
 
   async getContractInstance(address: ForeignCallSingle) {
     const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
-    return toForeignCallResult([
-      toArray([
+    return toForeignCallResult(
+      [
         instance.salt,
         instance.deployer.toField(),
         instance.currentContractClassId,
         instance.initializationHash,
         ...instance.publicKeys.toFields(),
-      ]),
-    ]);
+      ].map(toSingle),
+    );
   }
 
   async getPublicKeysAndPartialAddress(address: ForeignCallSingle) {
@@ -393,7 +396,7 @@ export class TXEService {
 
   async getKeyValidationRequest(pkMHash: ForeignCallSingle) {
     const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(fromSingle(pkMHash));
-    return toForeignCallResult([toArray(keyValidationRequest.toFields())]);
+    return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
   }
 
   async callPrivateFunction(
@@ -419,7 +422,7 @@ export class TXEService {
     if (!witness) {
       throw new Error(`Nullifier membership witness not found at block ${parsedBlockNumber}.`);
     }
-    return toForeignCallResult([toArray(witness.toFields())]);
+    return toForeignCallResult(witness.toNoirRepresentation());
   }
 
   async getAuthWitness(messageHash: ForeignCallSingle) {
@@ -482,7 +485,7 @@ export class TXEService {
     if (!header) {
       throw new Error(`Block header not found for block ${blockNumber}.`);
     }
-    return toForeignCallResult([toArray(header.toFields())]);
+    return toForeignCallResult(header.toFields().map(toSingle));
   }
 
   async getMembershipWitness(blockNumber: ForeignCallSingle, treeId: ForeignCallSingle, leafValue: ForeignCallSingle) {
@@ -495,7 +498,7 @@ export class TXEService {
         `Membership witness in tree ${MerkleTreeId[parsedTreeId]} not found for value ${parsedLeafValue} at block ${parsedBlockNumber}.`,
       );
     }
-    return toForeignCallResult([toArray(witness)]);
+    return toForeignCallResult([toSingle(witness[0]), toArray(witness.slice(1))]);
   }
 
   async getLowNullifierMembershipWitness(blockNumber: ForeignCallSingle, nullifier: ForeignCallSingle) {
@@ -505,7 +508,7 @@ export class TXEService {
     if (!witness) {
       throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${parsedBlockNumber}.`);
     }
-    return toForeignCallResult([toArray(witness.toFields())]);
+    return toForeignCallResult(witness.toNoirRepresentation());
   }
 
   async getIndexedTaggingSecretAsSender(sender: ForeignCallSingle, recipient: ForeignCallSingle) {
@@ -521,6 +524,42 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  public async deliverNote(
+    contractAddress: ForeignCallSingle,
+    storageSlot: ForeignCallSingle,
+    nonce: ForeignCallSingle,
+    content: ForeignCallArray,
+    contentLength: ForeignCallSingle,
+    noteHash: ForeignCallSingle,
+    nullifier: ForeignCallSingle,
+    txHash: ForeignCallSingle,
+    recipient: ForeignCallSingle,
+  ) {
+    await this.typedOracle.deliverNote(
+      AztecAddress.fromField(fromSingle(contractAddress)),
+      fromSingle(storageSlot),
+      fromSingle(nonce),
+      fromArray(content.slice(0, Number(BigInt(contentLength)))),
+      fromSingle(noteHash),
+      fromSingle(nullifier),
+      fromSingle(txHash),
+      AztecAddress.fromField(fromSingle(recipient)),
+    );
+
+    return toForeignCallResult([toSingle(Fr.ONE)]);
+  }
+
+  async getLogByTag(tag: ForeignCallSingle) {
+    // TODO(AD): this was warning that getLogByTag did not return a promise.
+    const log = await Promise.resolve(this.typedOracle.getLogByTag(fromSingle(tag)));
+
+    if (log == null) {
+      return toForeignCallResult([toSingle(Fr.ZERO), ...LogWithTxData.noirSerializationOfEmpty().map(toSingleOrArray)]);
+    } else {
+      return toForeignCallResult([toSingle(Fr.ONE), ...log.toNoirSerialization().map(toSingleOrArray)]);
+    }
+  }
+
   async storeCapsule(contractAddress: ForeignCallSingle, slot: ForeignCallSingle, capsule: ForeignCallArray) {
     await this.typedOracle.storeCapsule(
       AztecAddress.fromField(fromSingle(contractAddress)),
@@ -567,15 +606,31 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts. The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need to implement this function here. Isn't there a way to programmatically identify that this is missing, given the existence of a txe_oracle method?
-  async aes128Decrypt(ciphertext: ForeignCallArray, iv: ForeignCallArray, symKey: ForeignCallArray) {
-    const ciphertextBuffer = fromUintArray(ciphertext, 8);
+  // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts.
+  // The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need
+  // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
+  // existence of a txe_oracle method?
+  async aes128Decrypt(
+    ciphertextBVecStorage: ForeignCallArray,
+    ciphertextLength: ForeignCallSingle,
+    iv: ForeignCallArray,
+    symKey: ForeignCallArray,
+  ) {
+    const ciphertext = fromUintBoundedVec(ciphertextBVecStorage, ciphertextLength, 8);
     const ivBuffer = fromUintArray(iv, 8);
     const symKeyBuffer = fromUintArray(symKey, 8);
 
-    const plaintextBuffer = await this.typedOracle.aes128Decrypt(ciphertextBuffer, ivBuffer, symKeyBuffer);
+    const plaintextBuffer = await this.typedOracle.aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
 
-    return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), ciphertextBuffer.length));
+    return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), ciphertextBVecStorage.length));
+  }
+
+  async getSharedSecret(address: ForeignCallSingle, ephPk: ForeignCallArray) {
+    const secret = await this.typedOracle.getSharedSecret(
+      AztecAddress.fromField(fromSingle(address)),
+      Point.fromFields(fromArray(ephPk)),
+    );
+    return toForeignCallResult(secret.toFields().map(toSingle));
   }
 
   // AVM opcodes

package/src/util/encoding.ts

@@ -31,7 +31,7 @@ export function fromArray(obj: ForeignCallArray) {
 /**
  * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
  * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
- * @returns
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
  */
 export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer {
   if (uintBitSize % 8 !== 0) {
@@ -41,6 +41,24 @@ export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffe
   return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
 }
 
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ForeignCallArray and ForeignCallSingle values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export function fromUintBoundedVec(storage: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  const boundedStorage = storage.slice(0, fromSingle(length).toNumber());
+  return Buffer.concat(boundedStorage.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}
+
 export function toSingle(obj: Fr | AztecAddress): ForeignCallSingle {
   return obj.toString().slice(2);
 }
@@ -49,6 +67,10 @@ export function toArray(objs: Fr[]): ForeignCallArray {
   return objs.map(obj => obj.toString());
 }
 
+export function toSingleOrArray(value: Fr | Fr[]) {
+  return Array.isArray(value) ? value.map(toSingle) : toSingle(value);
+}
+
 export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
   return toArray(Array.from(buffer).map(byte => new Fr(byte)));
 }
@@ -57,21 +79,24 @@ export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
  * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
  * If the input array is shorter than the maxLen, it pads the result with zeros,
  * so that nr can correctly coerce this result into a BoundedVec.
- * @param array
+ * @param bVecStorage - The array underlying the BoundedVec.
  * @param maxLen - the max length of the BoundedVec.
  * @returns a tuple representing a BoundedVec.
  */
-export function arrayToBoundedVec(array: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle] {
-  if (array.length > maxLen) {
-    throw new Error(`Array of length ${array.length} larger than maxLen ${maxLen}`);
+export function arrayToBoundedVec(
+  bVecStorage: ForeignCallArray,
+  maxLen: number,
+): [ForeignCallArray, ForeignCallSingle] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
   }
-  const lengthDiff = maxLen - array.length;
+  const lengthDiff = maxLen - bVecStorage.length;
   // We pad the array to the maxLen of the BoundedVec.
   const zeroPaddingArray = toArray(Array(lengthDiff).fill(new Fr(0)));
 
   // These variable names match with the BoundedVec members in nr:
-  const storage = array.concat(zeroPaddingArray);
-  const len = toSingle(new Fr(array.length));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toSingle(new Fr(bVecStorage.length));
   return [storage, len];
 }
 

package/src/util/txe_public_contract_data_source.ts

@@ -16,14 +16,6 @@ import type { TXE } from '../oracle/txe_oracle.js';
 export class TXEPublicContractDataSource implements ContractDataSource {
   constructor(private txeOracle: TXE) {}
 
-  async getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined> {
-    const bytecode = await this.txeOracle.getContractDataProvider().getBytecode(address, selector);
-    if (!bytecode) {
-      return undefined;
-    }
-    return { bytecode, selector };
-  }
-
   getBlockNumber(): Promise<number> {
     return this.txeOracle.getBlockNumber();
   }
@@ -92,10 +84,4 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   registerContractFunctionSignatures(_address: AztecAddress, _signatures: []): Promise<void> {
     return Promise.resolve();
   }
-
-  // TODO(#10007): Remove this method.
-  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
-    // We don't really need to do anything for the txe here
-    return Promise.resolve();
-  }
 }

package/src/util/{txe_world_state_db.ts → txe_public_dbs.ts}

@@ -1,17 +1,16 @@
 import { Fr } from '@aztec/foundation/fields';
-import { WorldStateDB } from '@aztec/simulator/server';
+import { PublicTreesDB } from '@aztec/simulator/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
 
 import type { TXE } from '../oracle/txe_oracle.js';
 
-export class TXEWorldStateDB extends WorldStateDB {
-  constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, private txe: TXE) {
-    super(merkleDb, dataSource);
+export class TXEPublicTreesDB extends PublicTreesDB {
+  constructor(private merkleDb: MerkleTreeWriteOperations, private txe: TXE) {
+    super(merkleDb);
   }
 
   override async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {

package/dest/util/txe_world_state_db.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"txe_world_state_db.d.ts","sourceRoot":"","sources":["../../src/util/txe_world_state_db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAGjF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,eAAgB,SAAQ,YAAY;IACnC,OAAO,CAAC,QAAQ;IAA6D,OAAO,CAAC,GAAG;gBAAhF,QAAQ,EAAE,yBAAyB,EAAE,UAAU,EAAE,kBAAkB,EAAU,GAAG,EAAE,GAAG;IAI1F,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAgB1D,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3F"}