@aztec/simulator 0.70.0 → 0.72.1

package/src/acvm/oracle/oracle.ts

@@ -2,15 +2,12 @@ import { MerkleTreeId, UnencryptedL2Log } from '@aztec/circuit-types';
 import { FunctionSelector, NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
 
 import { type ACVMField } from '../acvm_types.js';
-import { frToBoolean, frToNumber, fromACVMField } from '../deserialize.js';
+import { frToBoolean, frToNumber, fromACVMField, fromBoundedVec } from '../deserialize.js';
 import { toACVMField } from '../serialize.js';
 import { type TypedOracle } from './typed_oracle.js';
 
-const logger = createLogger('simulator:acvm:oracle');
-
 /**
  * A data source that has all the apis required by Aztec.nr.
  */
@@ -22,11 +19,6 @@ export class Oracle {
     return toACVMField(val);
   }
 
-  async storeArrayInExecutionCache(values: ACVMField[]): Promise<ACVMField> {
-    const hash = await this.typedOracle.storeArrayInExecutionCache(values.map(fromACVMField));
-    return toACVMField(hash);
-  }
-
   // Since the argument is a slice, noir automatically adds a length field to oracle call.
   async storeInExecutionCache(_length: ACVMField[], values: ACVMField[]): Promise<ACVMField> {
     const hash = await this.typedOracle.storeInExecutionCache(values.map(fromACVMField));
@@ -384,34 +376,78 @@ export class Oracle {
     await this.typedOracle.syncNotes();
   }
 
-  async store([contract]: ACVMField[], [key]: ACVMField[], values: ACVMField[]) {
-    const processedContract = AztecAddress.fromField(fromACVMField(contract));
-    const processedKey = fromACVMField(key);
-    const processedValues = values.map(fromACVMField);
-    logger.debug(`Storing data for key ${processedKey} in contract ${processedContract}. Data: [${processedValues}]`);
-    await this.typedOracle.store(processedContract, processedKey, processedValues);
-  }
-
-  /**
-   * Load data from pxe db.
-   * @param contract - The contract address.
-   * @param key - The key to load.
-   * @param tSize - The size of the serialized object to return.
-   * @returns The data found flag and the serialized object concatenated in one array.
-   */
-  async load([contract]: ACVMField[], [key]: ACVMField[], [tSize]: ACVMField[]): Promise<(ACVMField | ACVMField[])[]> {
-    const processedContract = AztecAddress.fromField(fromACVMField(contract));
-    const processedKey = fromACVMField(key);
-    const values = await this.typedOracle.load(processedContract, processedKey);
+  async deliverNote(
+    [contractAddress]: ACVMField[],
+    [storageSlot]: ACVMField[],
+    [nonce]: ACVMField[],
+    content: ACVMField[],
+    [contentLength]: ACVMField[],
+    [noteHash]: ACVMField[],
+    [nullifier]: ACVMField[],
+    [txHash]: ACVMField[],
+    [recipient]: ACVMField[],
+  ): Promise<ACVMField> {
+    // TODO(#10728): try-catch this block and return false if we get an exception so that the contract can decide what
+    // to do if a note fails delivery (e.g. not increment the tagging index, or add it to some pending work list).
+    // Delivery might fail due to temporary issues, such as poor node connectivity.
+    await this.typedOracle.deliverNote(
+      AztecAddress.fromString(contractAddress),
+      fromACVMField(storageSlot),
+      fromACVMField(nonce),
+      fromBoundedVec(content, contentLength),
+      fromACVMField(noteHash),
+      fromACVMField(nullifier),
+      fromACVMField(txHash),
+      AztecAddress.fromString(recipient),
+    );
+
+    return toACVMField(true);
+  }
+
+  async dbStore([contractAddress]: ACVMField[], [slot]: ACVMField[], values: ACVMField[]) {
+    await this.typedOracle.dbStore(
+      AztecAddress.fromField(fromACVMField(contractAddress)),
+      fromACVMField(slot),
+      values.map(fromACVMField),
+    );
+  }
+
+  async dbLoad(
+    [contractAddress]: ACVMField[],
+    [slot]: ACVMField[],
+    [tSize]: ACVMField[],
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const values = await this.typedOracle.dbLoad(
+      AztecAddress.fromField(fromACVMField(contractAddress)),
+      fromACVMField(slot),
+    );
+
+    // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
+    // with two fields: `some` (a boolean) and `value` (a field array in this case).
     if (values === null) {
-      // No data was found so we set the data-found flag to 0 and we pad with zeros get the correct return size.
-      const processedTSize = frToNumber(fromACVMField(tSize));
-      logger.debug(`No data found for key ${processedKey} in contract ${processedContract}`);
-      return [toACVMField(0), Array(processedTSize).fill(toACVMField(0))];
+      // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
+      return [toACVMField(0), Array(frToNumber(fromACVMField(tSize))).fill(toACVMField(0))];
     } else {
-      // Data was found so we set the data-found flag to 1 and return it along with the data.
-      logger.debug(`Returning data for key ${processedKey} in contract ${processedContract}. Data: [${values}]`);
+      // Data was found so we set `some` to 1 and return it along with `value`.
       return [toACVMField(1), values.map(toACVMField)];
     }
   }
+
+  async dbDelete([contractAddress]: ACVMField[], [slot]: ACVMField[]) {
+    await this.typedOracle.dbDelete(AztecAddress.fromField(fromACVMField(contractAddress)), fromACVMField(slot));
+  }
+
+  async dbCopy(
+    [contractAddress]: ACVMField[],
+    [srcSlot]: ACVMField[],
+    [dstSlot]: ACVMField[],
+    [numEntries]: ACVMField[],
+  ) {
+    await this.typedOracle.dbCopy(
+      AztecAddress.fromField(fromACVMField(contractAddress)),
+      fromACVMField(srcSlot),
+      fromACVMField(dstSlot),
+      frToNumber(fromACVMField(numEntries)),
+    );
+  }
 }

package/src/acvm/oracle/typed_oracle.ts

@@ -56,10 +56,6 @@ export abstract class TypedOracle {
     return Fr.random();
   }
 
-  storeArrayInExecutionCache(_args: Fr[]): Promise<Fr> {
-    throw new OracleMethodNotAvailableError('storeArrayInExecutionCache');
-  }
-
   storeInExecutionCache(_values: Fr[]): Promise<Fr> {
     throw new OracleMethodNotAvailableError('storeInExecutionCache');
   }
@@ -237,11 +233,32 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('syncNotes');
   }
 
-  store(_contract: AztecAddress, _key: Fr, _values: Fr[]): Promise<void> {
-    throw new OracleMethodNotAvailableError('store');
+  deliverNote(
+    _contractAddress: AztecAddress,
+    _storageSlot: Fr,
+    _nonce: Fr,
+    _content: Fr[],
+    _noteHash: Fr,
+    _nullifier: Fr,
+    _txHash: Fr,
+    _recipient: AztecAddress,
+  ): Promise<void> {
+    throw new OracleMethodNotAvailableError('deliverNote');
+  }
+
+  dbStore(_contractAddress: AztecAddress, _key: Fr, _values: Fr[]): Promise<void> {
+    throw new OracleMethodNotAvailableError('dbStore');
+  }
+
+  dbLoad(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null> {
+    throw new OracleMethodNotAvailableError('dbLoad');
+  }
+
+  dbDelete(_contractAddress: AztecAddress, _key: Fr): Promise<void> {
+    throw new OracleMethodNotAvailableError('dbDelete');
   }
 
-  load(_contract: AztecAddress, _key: Fr): Promise<Fr[] | null> {
-    throw new OracleMethodNotAvailableError('load');
+  dbCopy(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void> {
+    throw new OracleMethodNotAvailableError('dbCopy');
   }
 }

package/src/avm/errors.ts

@@ -148,6 +148,16 @@ export class MSMPointNotOnCurveError extends AvmExecutionError {
   }
 }
 
+/**
+ * Error is thrown when some inputs of ToRadixBE are not valid.
+ */
+export class InvalidToRadixInputsError extends AvmExecutionError {
+  constructor(errorString: string) {
+    super(errorString);
+    this.name = 'InvalidToRadixInputsError';
+  }
+}
+
 /**
  * Error is thrown when a static call attempts to alter some state
  */

package/src/avm/journal/journal.ts

@@ -524,14 +524,13 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Write an unencrypted log
+   * Write a public log
    * @param contractAddress - address of the contract that emitted the log
-   * @param event - log event selector
    * @param log - log contents
    */
-  public writeUnencryptedLog(contractAddress: AztecAddress, log: Fr[]) {
-    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
-    this.trace.traceUnencryptedLog(contractAddress, log);
+  public writePublicLog(contractAddress: AztecAddress, log: Fr[]) {
+    this.log.debug(`PublicLog(${contractAddress}) += event with ${log.length} fields.`);
+    this.trace.tracePublicLog(contractAddress, log);
   }
 
   /**

package/src/avm/opcodes/accrued_substate.ts

@@ -201,6 +201,7 @@ export class L1ToL2MessageExists extends Instruction {
 }
 
 export class EmitUnencryptedLog extends Instruction {
+  // TODO(#11124): rename unencrypted -> public
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
@@ -228,7 +229,7 @@ export class EmitUnencryptedLog extends Instruction {
 
     context.machineState.consumeGas(this.gasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writeUnencryptedLog(contractAddress, log);
+    context.persistableState.writePublicLog(contractAddress, log);
 
     memory.assert({ reads: 1 + logSize, addressing });
   }

package/src/avm/opcodes/conversion.ts

@@ -1,12 +1,12 @@
 import { type AvmContext } from '../avm_context.js';
 import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
+import { InvalidToRadixInputsError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 export class ToRadixBE extends Instruction {
-  static type: string = 'TORADIXLE';
+  static type: string = 'TORADIXBE';
   static readonly opcode: Opcode = Opcode.TORADIXBE;
 
   // Informs (de)serialization. See Instruction.deserialize.
@@ -49,12 +49,21 @@ export class ToRadixBE extends Instruction {
 
     let value: bigint = memory.get(srcOffset).toBigInt();
     const radix: bigint = memory.get(radixOffset).toBigInt();
-    if (numLimbs < 1) {
-      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${numLimbs})`);
+
+    if (radix < 2 || radix > 256) {
+      throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
     }
-    if (radix > 256) {
-      throw new InstructionExecutionError(`ToRadixBE instruction's radix should be <= 256 (was ${radix})`);
+
+    if (numLimbs < 1 && value != BigInt(0n)) {
+      throw new InvalidToRadixInputsError(
+        `ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`,
+      );
     }
+
+    if (outputBits != 0 && radix != BigInt(2n)) {
+      throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
+    }
+
     const radixBN: bigint = BigInt(radix);
     const limbArray = new Array(numLimbs);
 

package/src/avm/opcodes/ec_add.ts

@@ -81,7 +81,7 @@ export class EcAdd extends Instruction {
     } else if (p2IsInfinite) {
       dest = p1;
     } else {
-      dest = grumpkin.add(p1, p2);
+      dest = await grumpkin.add(p1, p2);
     }
 
     // Important to use setSlice() and not set() in the two following statements as

package/src/avm/opcodes/memory.ts

@@ -190,7 +190,10 @@ export class CalldataCopy extends Instruction {
     const copySize = memory.get(copySizeOffset).toNumber();
     context.machineState.consumeGas(this.gasCost(copySize));
 
-    const transformedData = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
+    // Values which are out-of-range of the calldata array will be set with Field(0);
+    const slice = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
+    // slice has size = MIN(copySize, calldata.length - cdStart) as TS truncates out-of-range portion
+    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
 
     memory.setSlice(dstOffset, transformedData);
 
@@ -253,9 +256,10 @@ export class ReturndataCopy extends Instruction {
     const copySize = memory.get(copySizeOffset).toNumber();
     context.machineState.consumeGas(this.gasCost(copySize));
 
-    const transformedData = context.machineState.nestedReturndata
-      .slice(rdStart, rdStart + copySize)
-      .map(f => new Field(f));
+    // Values which are out-of-range of the returndata array will be set with Field(0);
+    const slice = context.machineState.nestedReturndata.slice(rdStart, rdStart + copySize).map(f => new Field(f));
+    // slice has size = MIN(copySize, returndata.length - rdStart) as TS truncates out-of-range portion
+    const transformedData = [...slice, ...Array(copySize - slice.length).fill(new Field(0))];
 
     memory.setSlice(dstOffset, transformedData);
 

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -95,20 +95,22 @@ export class MultiScalarMul extends Instruction {
     const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
     // Fold the points and scalars into a single point
     // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
-    const outputPoint = rest.reduce((acc, curr) => {
+    let acc = await grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]);
+    for (const curr of rest) {
       if (curr[1] === Fq.ZERO) {
         // If we multiply by 0, the result will the point at infinity - so we ignore it
-        return acc;
+        continue;
       } else if (curr[0].inf) {
         // If we multiply the point at infinity by a scalar, it's still the point at infinity
-        return acc;
+        continue;
       } else if (acc.inf) {
         // If we accumulator is the point at infinity, we can just return the current point
-        return curr[0];
+        acc = curr[0];
       } else {
-        return grumpkin.add(acc, grumpkin.mul(curr[0], curr[1]));
+        acc = await grumpkin.add(acc, await grumpkin.mul(curr[0], curr[1]));
       }
-    }, grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]));
+    }
+    const outputPoint = acc;
 
     // Important to use setSlice() and not set() in the two following statements as
     // this checks that the offsets lie within memory range.

package/src/client/client_execution_context.ts

@@ -95,7 +95,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const args = this.executionCache.getPreimage(this.argsHash);
 
     if (args.length !== argumentsSize) {
-      throw new Error('Invalid arguments size');
+      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args.length}`);
     }
 
     const privateContextInputs = new PrivateContextInputs(
@@ -160,14 +160,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.publicTeardownFunctionCall;
   }
 
-  /**
-   * Store values in the execution cache.
-   * @param values - Values to store.
-   */
-  public override storeArrayInExecutionCache(args: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.executionCache.store(args));
-  }
-
   /**
    * Store values in the execution cache.
    * @param values - Values to store.
@@ -327,6 +319,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * This fn exists because sha hashing the preimage
    * is too large to compile (16,200 fields, 518,400 bytes) => the oracle hashes it.
    * See private_context.nr
+   * TODO(#8945): Contract class logs are currently sha hashes. When these are fields, delete this.
    * @param log - The unencrypted log to be emitted.
    */
   public override emitContractClassLog(log: UnencryptedL2Log, counter: number) {

package/src/client/db_oracle.ts

@@ -233,26 +233,69 @@ export interface DBOracle extends CommitmentsDB {
    */
   processTaggedLogs(logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
 
+  /**
+   * Delivers the preimage and metadata of a committed note so that it can be later requested via the `getNotes`
+   * oracle.
+   *
+   * @param contractAddress - The address of the contract that created the note (i.e. the siloing contract)
+   * @param storageSlot - The storage slot of the note - used for indexing in `getNotes`
+   * @param nonce - The nonce of the note used by the kernel to compute the unique note hash
+   * @param content - The note's content: this is the primary item to return in `getNotes`
+   * @param noteHash - The non-unique non-siloed note hash
+   * @param nullifier - The inner (non-siloed) note nullifier
+   * @param txHash - The transaction in which the note was added to the note hash tree
+   * @param recipient - The account that discovered the note
+   */
+  deliverNote(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ): Promise<void>;
+
   /**
    * Removes all of a contract's notes that have been nullified from the note database.
    */
   removeNullifiedNotes(contractAddress: AztecAddress): Promise<void>;
 
   /**
-   * 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 - An address of a contract that is requesting to store the data.
-   * @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.
+   * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `dbLoad`.
+   * * If data was already stored at this slot, it is overwrriten.
+   * @param contractAddress - The contract address to scope the data under.
+   * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
+   * @param values - The data to store.
    */
-  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void>;
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void>;
 
   /**
-   * 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 - An address of a contract that is requesting to load the data.
-   * @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.
+   * Returns data previously stored via `dbStore` in the per-contract non-volatile database.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to read.
+   * @returns The stored data or `null` if no data is stored under the slot.
+   */
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+
+  /**
+   * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to delete.
+   */
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void>;
+
+  /**
+   * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
+   * structures by avoiding repeated calls to `dbLoad` and `dbStore`.
+   * Supports overlapping source and destination regions (which will result in the overlapped source values being
+   * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
+   *
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param srcSlot - The first slot to copy from.
+   * @param dstSlot - The first slot to copy to.
+   * @param numEntries - The number of entries to copy.
    */
-  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null>;
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
 }

package/src/client/private_execution.ts

@@ -29,7 +29,7 @@ export async function executePrivateFunction(
   log = createLogger('simulator:private_execution'),
 ): Promise<PrivateCallExecutionResult> {
   const functionName = await context.getDebugFunctionName();
-  log.verbose(`Executing private function ${functionName}@${contractAddress}`);
+  log.verbose(`Executing private function ${functionName}`, { contract: contractAddress });
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);

package/src/client/simulator.ts

@@ -192,7 +192,7 @@ export class AcirSimulator {
     const execRequest: FunctionCall = {
       name: artifact.name,
       to: contractAddress,
-      selector: FunctionSelector.empty(),
+      selector: FunctionSelector.fromNameAndParameters(artifact),
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
       args: encodeArguments(artifact, [

package/src/client/unconstrained_execution.ts

@@ -22,7 +22,10 @@ export async function executeUnconstrainedFunction(
   args: Fr[],
   log = createLogger('simulator:unconstrained_execution'),
 ): Promise<AbiDecoded> {
-  log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
+  log.verbose(`Executing unconstrained function ${artifact.name}`, {
+    contract: contractAddress,
+    selector: functionSelector,
+  });
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);

package/src/client/view_data_oracle.ts

@@ -310,23 +310,53 @@ export class ViewDataOracle extends TypedOracle {
     await this.db.removeNullifiedNotes(this.contractAddress);
   }
 
-  public override 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}`,
-      );
+  public override async deliverNote(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    nonce: Fr,
+    content: Fr[],
+    noteHash: Fr,
+    nullifier: Fr,
+    txHash: Fr,
+    recipient: AztecAddress,
+  ) {
+    // TODO(#10727): allow other contracts to deliver notes
+    if (!this.contractAddress.equals(contractAddress)) {
+      throw new Error(`Got a note delivery request from ${contractAddress}, expected ${this.contractAddress}`);
     }
-    return this.db.store(this.contractAddress, key, values);
+
+    await this.db.deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient);
   }
 
-  public override 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
-      throw new Error(
-        `Contract address ${contract} does not match the oracle's contract address ${this.contractAddress}`,
-      );
+  public override 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.db.dbStore(this.contractAddress, slot, values);
+  }
+
+  public override 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.db.dbLoad(this.contractAddress, slot);
+  }
+
+  public override 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.db.dbDelete(this.contractAddress, slot);
+  }
+
+  public override 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.db.load(this.contractAddress, key);
+    return this.db.dbCopy(this.contractAddress, srcSlot, dstSlot, numEntries);
   }
 }