@aztec/txe 0.70.0 → 0.72.1

package/src/node/txe_node.ts

@@ -2,9 +2,11 @@ import { createLogger } from '@aztec/aztec.js';
 import {
   type AztecNode,
   type EpochProofQuote,
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   type L2Block,
+  L2BlockHash,
   type L2BlockNumber,
   type L2Tips,
   type LogFilter,
@@ -18,10 +20,9 @@ import {
   type Tx,
   type TxEffect,
   TxHash,
-  type TxReceipt,
+  TxReceipt,
   TxScopedL2Log,
   type TxValidationResult,
-  type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
@@ -35,31 +36,38 @@ import {
   type NULLIFIER_TREE_HEIGHT,
   type NodeInfo,
   type PUBLIC_DATA_TREE_HEIGHT,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
   type PrivateLog,
   type ProtocolContractAddresses,
+  type PublicLog,
 } from '@aztec/circuits.js';
 import { type L1ContractAddresses } from '@aztec/ethereum';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
 
 export class TXENode implements AztecNode {
   #logsByTags = new Map<string, TxScopedL2Log[]>();
-  #txEffectsByTxHash = new Map<string, InBlock<TxEffect> | undefined>();
+  #txEffectsByTxHash = new Map<string, InBlock<TxEffect>>();
+  #txReceiptsByTxHash = new Map<string, TxReceipt>();
   #blockNumberToNullifiers = new Map<number, Fr[]>();
   #noteIndex = 0;
 
-  #blockNumber: number;
   #logger = createLogger('aztec:txe_node');
 
-  constructor(blockNumber: number) {
-    this.#blockNumber = blockNumber;
-  }
+  constructor(
+    private blockNumber: number,
+    private version: number,
+    private chainId: number,
+    private trees: MerkleTrees,
+  ) {}
 
   /**
    * Fetches the current block number.
    * @returns The block number.
    */
   getBlockNumber(): Promise<number> {
-    return Promise.resolve(this.#blockNumber);
+    return Promise.resolve(this.blockNumber);
   }
 
   /**
@@ -67,7 +75,7 @@ export class TXENode implements AztecNode {
    * @param - The block number to set.
    */
   setBlockNumber(blockNumber: number) {
-    this.#blockNumber = blockNumber;
+    this.blockNumber = blockNumber;
   }
 
   /**
@@ -76,23 +84,42 @@ export class TXENode implements AztecNode {
    * @returns The requested tx effect.
    */
   getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
-    const txEffect = this.#txEffectsByTxHash.get(new Fr(txHash.toBuffer()).toString());
+    const txEffect = this.#txEffectsByTxHash.get(txHash.toString());
 
     return Promise.resolve(txEffect);
   }
 
   /**
-   * Sets a tx effect for a given block number.
+   * Sets a tx effect and receipt for a given block number.
    * @param blockNumber - The block number that this tx effect resides.
    * @param txHash - The transaction hash of the transaction.
    * @param effect - The tx effect to set.
    */
   setTxEffect(blockNumber: number, txHash: TxHash, effect: TxEffect) {
-    this.#txEffectsByTxHash.set(new Fr(txHash.toBuffer()).toString(), {
-      l2BlockHash: blockNumber.toString(),
+    // We are not creating real blocks on which membership proofs can be constructed - we instead define its hash as
+    // simply the hash of the block number.
+    const blockHash = poseidon2Hash([blockNumber]);
+
+    this.#txEffectsByTxHash.set(txHash.toString(), {
+      l2BlockHash: blockHash.toString(),
       l2BlockNumber: blockNumber,
       data: effect,
     });
+
+    // We also set the receipt since we want to be able to serve `getTxReceipt` - we don't care about most values here,
+    // but we do need to be able to retrieve the block number of a given txHash.
+    this.#txReceiptsByTxHash.set(
+      txHash.toString(),
+      new TxReceipt(
+        txHash,
+        TxReceipt.statusFromRevertCode(effect.revertCode),
+        '',
+        undefined,
+        new L2BlockHash(blockHash.toBuffer()),
+        blockNumber,
+        undefined,
+      ),
+    );
   }
 
   /**
@@ -167,45 +194,48 @@ export class TXENode implements AztecNode {
   /**
    * Adds public logs to the txe node, given a block
    * @param blockNumber - The block number at which to add the public logs.
-   * @param privateLogs - The unencrypted logs to be added.
-   */
-  addPublicLogsByTags(blockNumber: number, unencryptedLogs: UnencryptedL2Log[]) {
-    unencryptedLogs.forEach(log => {
-      if (log.data.length < 32 * 33) {
-        // TODO remove when #9835 and #9836 are fixed
-        this.#logger.warn(`Skipping unencrypted log with insufficient data length: ${log.data.length}`);
+   * @param publicLogs - The public logs to be added.
+   */
+  addPublicLogsByTags(blockNumber: number, publicLogs: PublicLog[]) {
+    publicLogs.forEach(log => {
+      // Check that each log stores 3 lengths in its first field. If not, it's not a tagged log:
+      const firstFieldBuf = log.log[0].toBuffer();
+      if (
+        !firstFieldBuf.subarray(0, 24).equals(Buffer.alloc(24)) ||
+        firstFieldBuf[26] !== 0 ||
+        firstFieldBuf[29] !== 0
+      ) {
+        // See parseLogFromPublic - the first field of a tagged log is 8 bytes structured:
+        // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1], 0, ciphertextLen[0], ciphertextLen[1]]
+        this.#logger.warn(`Skipping public log with invalid first field: ${log.log[0]}`);
         return;
       }
-      try {
-        // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
-        // This means that for every 32 bytes of payload, we only have 1 byte of data.
-        // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
-        const correctedBuffer = Buffer.alloc(32);
-        const initialOffset = 32;
-        for (let i = 0; i < 32; i++) {
-          const byte = Fr.fromBuffer(log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset)).toNumber();
-          correctedBuffer.writeUInt8(byte, i);
-        }
-        const tag = new Fr(correctedBuffer);
-
-        this.#logger.verbose(
-          `Found tagged unencrypted log with tag ${tag.toString()} in block ${this.getBlockNumber()}`,
-        );
-
-        const currentLogs = this.#logsByTags.get(tag.toString()) ?? [];
-        const scopedLog = new TxScopedL2Log(
-          new TxHash(new Fr(blockNumber)),
-          this.#noteIndex,
-          blockNumber,
-          true,
-          log.toBuffer(),
-        );
-
-        currentLogs.push(scopedLog);
-        this.#logsByTags.set(tag.toString(), currentLogs);
-      } catch (err) {
-        this.#logger.warn(`Failed to add tagged log to store: ${err}`);
+      // Check that the length values line up with the log contents
+      const publicValuesLength = firstFieldBuf.subarray(-8).readUint16BE();
+      const privateValuesLength = firstFieldBuf.subarray(-8).readUint16BE(3);
+      // Add 1 for the first field holding lengths
+      const totalLogLength = 1 + publicValuesLength + privateValuesLength;
+      // Note that zeroes can be valid log values, so we can only assert that we do not go over the given length
+      if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find(f => !f.isZero())) {
+        this.#logger.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
+        return;
       }
+      // The first elt stores lengths => tag is in fields[1]
+      const tag = log.log[1];
+
+      this.#logger.verbose(`Found tagged public log with tag ${tag.toString()} in block ${this.getBlockNumber()}`);
+
+      const currentLogs = this.#logsByTags.get(tag.toString()) ?? [];
+      const scopedLog = new TxScopedL2Log(
+        new TxHash(new Fr(blockNumber)),
+        this.#noteIndex,
+        blockNumber,
+        true,
+        log.toBuffer(),
+      );
+
+      currentLogs.push(scopedLog);
+      this.#logsByTags.set(tag.toString(), currentLogs);
     });
   }
   /**
@@ -234,12 +264,29 @@ export class TXENode implements AztecNode {
    * @param leafValue - The values to search for
    * @returns The indexes of the given leaves in the given tree or undefined if not found.
    */
-  findLeavesIndexes(
-    _blockNumber: L2BlockNumber,
-    _treeId: MerkleTreeId,
-    _leafValues: Fr[],
+  async findLeavesIndexes(
+    blockNumber: L2BlockNumber,
+    treeId: MerkleTreeId,
+    leafValues: Fr[],
   ): Promise<(bigint | undefined)[]> {
-    throw new Error('TXE Node method findLeavesIndexes not implemented');
+    // Temporary workaround to be able to respond this query: the trees are currently stored in the TXE oracle, but we
+    // hold a reference to them.
+    // We should likely migrate this so that the trees are owned by the node.
+
+    // TODO: blockNumber is being passed as undefined, figure out why
+    if (blockNumber === 'latest' || blockNumber === undefined) {
+      blockNumber = await this.getBlockNumber();
+    }
+
+    const db =
+      blockNumber === (await this.getBlockNumber())
+        ? await this.trees.getLatest()
+        : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+
+    return await db.findLeafIndices(
+      treeId,
+      leafValues.map(x => x.toBuffer()),
+    );
   }
 
   /**
@@ -420,7 +467,7 @@ export class TXENode implements AztecNode {
    * @returns The rollup version.
    */
   getVersion(): Promise<number> {
-    throw new Error('TXE Node method getVersion not implemented');
+    return Promise.resolve(this.version);
   }
 
   /**
@@ -428,7 +475,7 @@ export class TXENode implements AztecNode {
    * @returns The chain id.
    */
   getChainId(): Promise<number> {
-    throw new Error('TXE Node method getChainId not implemented');
+    return Promise.resolve(this.chainId);
   }
 
   /**
@@ -456,12 +503,12 @@ export class TXENode implements AztecNode {
   }
 
   /**
-   * Gets unencrypted logs based on the provided filter.
+   * Gets public logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getUnencryptedLogs(_filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    throw new Error('TXE Node method getUnencryptedLogs not implemented');
+  getPublicLogs(_filter: LogFilter): Promise<GetPublicLogsResponse> {
+    throw new Error('TXE Node method getPublicLogs not implemented');
   }
 
   /**
@@ -469,7 +516,7 @@ export class TXENode implements AztecNode {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getContractClassLogs(_filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getContractClassLogs(_filter: LogFilter): Promise<GetContractClassLogsResponse> {
     throw new Error('TXE Node method getContractClassLogs not implemented');
   }
 
@@ -490,8 +537,13 @@ export class TXENode implements AztecNode {
    * @param txHash - The transaction hash.
    * @returns A receipt of the transaction.
    */
-  getTxReceipt(_txHash: TxHash): Promise<TxReceipt> {
-    throw new Error('TXE Node method getTxReceipt not implemented');
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    const txEffect = this.#txReceiptsByTxHash.get(txHash.toString());
+    if (!txEffect) {
+      throw new Error('Unknown txHash');
+    }
+
+    return Promise.resolve(txEffect);
   }
 
   /**

package/src/oracle/txe_oracle.ts

@@ -35,6 +35,7 @@ import {
   PublicDataTreeLeaf,
   type PublicDataTreeLeafPreimage,
   type PublicDataWrite,
+  type PublicLog,
   computeContractClassId,
   computeTaggingSecretPoint,
   deriveKeys,
@@ -84,7 +85,6 @@ import {
   createSimulationError,
   resolveAssertionMessageFromError,
 } from '@aztec/simulator/server';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
 
 import { TXENode } from '../node/txe_node.js';
@@ -95,7 +95,6 @@ import { TXEWorldStateDB } from '../util/txe_world_state_db.js';
 export class TXE implements TypedOracle {
   private blockNumber = 0;
   private sideEffectCounter = 0;
-  private contractAddress: AztecAddress;
   private msgSender: AztecAddress;
   private functionSelector = FunctionSelector.fromField(new Fr(0));
   private isStaticCall = false;
@@ -105,17 +104,17 @@ export class TXE implements TypedOracle {
   private contractDataOracle: ContractDataOracle;
   private simulatorOracle: SimulatorOracle;
 
-  private version: Fr = Fr.ONE;
-  private chainId: Fr = Fr.ONE;
-
   private uniqueNoteHashesFromPublic: Fr[] = [];
   private siloedNullifiersFromPublic: Fr[] = [];
   private privateLogs: PrivateLog[] = [];
-  private publicLogs: UnencryptedL2Log[] = [];
+  private publicLogs: PublicLog[] = [];
 
   private committedBlocks = new Set<number>();
 
-  private node = new TXENode(this.blockNumber);
+  private VERSION = 1;
+  private CHAIN_ID = 1;
+
+  private node: TXENode;
 
   private simulationProvider = new WASMSimulator();
 
@@ -123,16 +122,19 @@ export class TXE implements TypedOracle {
 
   debug: LogFn;
 
-  constructor(
+  private constructor(
     private logger: Logger,
     private trees: MerkleTrees,
     private executionCache: HashedValuesCache,
     private keyStore: KeyStore,
     private txeDatabase: TXEDatabase,
+    private contractAddress: AztecAddress,
   ) {
     this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
     this.contractDataOracle = new ContractDataOracle(txeDatabase);
-    this.contractAddress = AztecAddress.random();
+
+    this.node = new TXENode(this.blockNumber, this.VERSION, this.CHAIN_ID, this.trees);
+
     // Default msg_sender (for entrypoints) is now Fr.max_value rather than 0 addr (see #7190 & #7404)
     this.msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE);
     this.simulatorOracle = new SimulatorOracle(
@@ -146,6 +148,16 @@ export class TXE implements TypedOracle {
     this.debug = createDebugOnlyLogger('aztec:kv-pxe-database');
   }
 
+  static async create(
+    logger: Logger,
+    trees: MerkleTrees,
+    executionCache: HashedValuesCache,
+    keyStore: KeyStore,
+    txeDatabase: TXEDatabase,
+  ) {
+    return new TXE(logger, trees, executionCache, keyStore, txeDatabase, await AztecAddress.random());
+  }
+
   // Utils
 
   async #getTreesAt(blockNumber: number) {
@@ -156,12 +168,12 @@ export class TXE implements TypedOracle {
     return db;
   }
 
-  getChainId() {
-    return Promise.resolve(this.chainId);
+  getChainId(): Promise<Fr> {
+    return Promise.resolve(this.node.getChainId().then(id => new Fr(id)));
   }
 
-  getVersion() {
-    return Promise.resolve(this.version);
+  getVersion(): Promise<Fr> {
+    return Promise.resolve(this.node.getVersion().then(v => new Fr(v)));
   }
 
   getMsgSender() {
@@ -232,8 +244,8 @@ export class TXE implements TypedOracle {
 
     const stateReference = await db.getStateReference();
     const inputs = PrivateContextInputs.empty();
-    inputs.txContext.chainId = this.chainId;
-    inputs.txContext.version = this.version;
+    inputs.txContext.chainId = new Fr(await this.node.getChainId());
+    inputs.txContext.version = new Fr(await this.node.getVersion());
     inputs.historicalHeader.globalVariables.blockNumber = new Fr(blockNumber);
     inputs.historicalHeader.state = stateReference;
     inputs.historicalHeader.lastArchive.root = Fr.fromBuffer(
@@ -252,8 +264,8 @@ export class TXE implements TypedOracle {
     const account = await this.txeDatabase.getAccount(address);
     const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
     const schnorr = new Schnorr();
-    const signature = schnorr.constructSignature(messageHash.toBuffer(), privateKey).toBuffer();
-    const authWitness = new AuthWitness(messageHash, [...signature]);
+    const signature = await schnorr.constructSignature(messageHash.toBuffer(), privateKey);
+    const authWitness = new AuthWitness(messageHash, [...signature.toBuffer()]);
     return this.txeDatabase.addAuthWitness(authWitness.requestHash, authWitness.witness);
   }
 
@@ -322,26 +334,13 @@ export class TXE implements TypedOracle {
     this.privateLogs.push(...privateLogs);
   }
 
-  addPublicLogs(logs: UnencryptedL2Log[]) {
+  addPublicLogs(logs: PublicLog[]) {
     logs.forEach(log => {
-      if (log.data.length < 32 * 33) {
-        // TODO remove when #9835 and #9836 are fixed
-        this.logger.warn(`Skipping unencrypted log with insufficient data length: ${log.data.length}`);
-        return;
-      }
       try {
-        // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
-        // This means that for every 32 bytes of payload, we only have 1 byte of data.
-        // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
-        const correctedBuffer = Buffer.alloc(32);
-        const initialOffset = 32;
-        for (let i = 0; i < 32; i++) {
-          const byte = Fr.fromBuffer(log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset)).toNumber();
-          correctedBuffer.writeUInt8(byte, i);
-        }
-        const tag = new Fr(correctedBuffer);
-
-        this.logger.verbose(`Found tagged unencrypted log with tag ${tag.toString()} in block ${this.blockNumber}`);
+        // The first elt stores lengths => tag is in fields[1]
+        const tag = log.log[1];
+
+        this.logger.verbose(`Found tagged public log with tag ${tag.toString()} in block ${this.blockNumber}`);
         this.publicLogs.push(log);
       } catch (err) {
         this.logger.warn(`Failed to add tagged log to store: ${err}`);
@@ -371,10 +370,6 @@ export class TXE implements TypedOracle {
     return Fr.random();
   }
 
-  storeArrayInExecutionCache(values: Fr[]) {
-    return Promise.resolve(this.executionCache.store(values));
-  }
-
   storeInExecutionCache(values: Fr[]) {
     return Promise.resolve(this.executionCache.store(values));
   }
@@ -406,11 +401,11 @@ export class TXE implements TypedOracle {
     return [new Fr(index), ...siblingPath.toFields()];
   }
 
-  async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
-    const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-    const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
-    return result.toFields();
-  }
+  // async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
+  //   const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+  //   const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
+  //   return result.toFields();
+  // }
 
   async getNullifierMembershipWitness(
     blockNumber: number,
@@ -810,8 +805,8 @@ export class TXE implements TypedOracle {
     const worldStateDb = new TXEWorldStateDB(db, new TXEPublicContractDataSource(this));
 
     const globalVariables = GlobalVariables.empty();
-    globalVariables.chainId = this.chainId;
-    globalVariables.version = this.version;
+    globalVariables.chainId = new Fr(await this.node.getChainId());
+    globalVariables.version = new Fr(await this.node.getVersion());
     globalVariables.blockNumber = new Fr(this.blockNumber);
     globalVariables.gasFees = new GasFees(1, 1);
 
@@ -830,23 +825,33 @@ export class TXE implements TypedOracle {
     const simulator = new PublicTxSimulator(
       db,
       new TXEWorldStateDB(db, new TXEPublicContractDataSource(this)),
-      new NoopTelemetryClient(),
       globalVariables,
     );
 
+    const { usedTxRequestHashForNonces } = this.noteCache.finish();
+    const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
+
     // When setting up a teardown call, we tell it that
     // private execution used Gas(1, 1) so it can compute a tx fee.
     const gasUsedByPrivate = isTeardown ? new Gas(1, 1) : Gas.empty();
     const tx = createTxForPublicCalls(
       /*setupExecutionRequests=*/ [],
       /*appExecutionRequests=*/ isTeardown ? [] : [executionRequest],
+      firstNullifier,
       /*teardownExecutionRequests=*/ isTeardown ? executionRequest : undefined,
       gasUsedByPrivate,
     );
 
     const result = await simulator.simulate(tx);
+    const noteHashes = result.avmProvingRequest.inputs.output.accumulatedData.noteHashes.filter(s => !s.isEmpty());
 
-    this.addPublicLogs(tx.unencryptedLogs.unrollLogs());
+    await this.addUniqueNoteHashesFromPublic(noteHashes);
+
+    this.addPublicLogs(
+      result.avmProvingRequest.inputs.output.accumulatedData.publicLogs.filter(
+        log => !log.contractAddress.equals(AztecAddress.ZERO),
+      ),
+    );
 
     return Promise.resolve(result);
   }
@@ -898,7 +903,11 @@ export class TXE implements TypedOracle {
     const sideEffects = executionResult.avmProvingRequest.inputs.output.accumulatedData;
     const publicDataWrites = sideEffects.publicDataWrites.filter(s => !s.isEmpty());
     const noteHashes = sideEffects.noteHashes.filter(s => !s.isEmpty());
-    const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty());
+
+    const { usedTxRequestHashForNonces } = this.noteCache.finish();
+    const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
+    const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty()).filter(s => !s.equals(firstNullifier));
+
     await this.addPublicDataWrites(publicDataWrites);
     await this.addUniqueNoteHashesFromPublic(noteHashes);
     await this.addSiloedNullifiers(nullifiers);
@@ -952,7 +961,7 @@ export class TXE implements TypedOracle {
   async #calculateAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
     const senderCompleteAddress = await this.getCompleteAddress(sender);
     const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-    const secretPoint = computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
+    const secretPoint = await computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
     // Silo the secret to the app so it can't be used to track other app's notes
     const appSecret = poseidon2Hash([secretPoint.x, secretPoint.y, contractAddress]);
     return appSecret;
@@ -974,6 +983,19 @@ export class TXE implements TypedOracle {
     return Promise.resolve();
   }
 
+  deliverNote(
+    _contractAddress: AztecAddress,
+    _storageSlot: Fr,
+    _nonce: Fr,
+    _content: Fr[],
+    _noteHash: Fr,
+    _nullifier: Fr,
+    _txHash: Fr,
+    _recipient: AztecAddress,
+  ): Promise<void> {
+    throw new Error('deliverNote');
+  }
+
   // AVM oracles
 
   async avmOpcodeCall(targetContractAddress: AztecAddress, args: Fr[], isStaticCall: boolean): Promise<PublicTxResult> {
@@ -999,7 +1021,11 @@ export class TXE implements TypedOracle {
       const sideEffects = executionResult.avmProvingRequest.inputs.output.accumulatedData;
       const publicDataWrites = sideEffects.publicDataWrites.filter(s => !s.isEmpty());
       const noteHashes = sideEffects.noteHashes.filter(s => !s.isEmpty());
-      const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty());
+      const { usedTxRequestHashForNonces } = this.noteCache.finish();
+      const firstNullifier = usedTxRequestHashForNonces
+        ? this.getTxRequestHash()
+        : this.noteCache.getAllNullifiers()[0];
+      const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty()).filter(s => !s.equals(firstNullifier));
       await this.addPublicDataWrites(publicDataWrites);
       await this.addUniqueNoteHashes(noteHashes);
       await this.addSiloedNullifiers(nullifiers);
@@ -1058,36 +1084,35 @@ export class TXE implements TypedOracle {
     return preimage.value;
   }
 
-  /**
-   * Used by contracts during execution to store arbitrary data in the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - The contract address to store the data under.
-   * @param key - A field element representing the key to store the data under.
-   * @param values - An array of field elements representing the data to store.
-   */
-  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void> {
-    if (!contract.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
-      throw new Error(
-        `Contract address ${contract} does not match the oracle's contract address ${this.contractAddress}`,
-      );
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.txeDatabase.store(this.contractAddress, key, values);
-  }
-
-  /**
-   * Used by contracts during execution to load arbitrary data from the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - The contract address to load the data from.
-   * @param key - A field element representing the key under which to load the data..
-   * @returns An array of field elements representing the stored data or `null` if no data is stored under the key.
-   */
-  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null> {
-    if (!contract.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
-      this.debug(`Data not found for contract ${contract.toString()} and key ${key.toString()}`);
-      return Promise.resolve(null);
+    return this.txeDatabase.dbStore(this.contractAddress, slot, values);
+  }
+
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbLoad(this.contractAddress, slot);
+  }
+
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+    }
+    return this.txeDatabase.dbDelete(this.contractAddress, slot);
+  }
+
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    if (!contractAddress.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.txeDatabase.load(this.contractAddress, key);
+    return this.txeDatabase.dbCopy(this.contractAddress, srcSlot, dstSlot, numEntries);
   }
 }