@aztec/simulator 0.80.0 → 0.81.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.80.0",
+  "version": "0.81.0",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
@@ -59,16 +59,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.80.0",
-    "@aztec/foundation": "0.80.0",
-    "@aztec/noir-acvm_js": "0.80.0",
-    "@aztec/noir-noirc_abi": "0.80.0",
-    "@aztec/noir-protocol-circuits-types": "0.80.0",
-    "@aztec/noir-types": "0.80.0",
-    "@aztec/protocol-contracts": "0.80.0",
-    "@aztec/stdlib": "0.80.0",
-    "@aztec/telemetry-client": "0.80.0",
-    "@aztec/world-state": "0.80.0",
+    "@aztec/constants": "0.81.0",
+    "@aztec/foundation": "0.81.0",
+    "@aztec/noir-acvm_js": "0.81.0",
+    "@aztec/noir-noirc_abi": "0.81.0",
+    "@aztec/noir-protocol-circuits-types": "0.81.0",
+    "@aztec/noir-types": "0.81.0",
+    "@aztec/protocol-contracts": "0.81.0",
+    "@aztec/stdlib": "0.81.0",
+    "@aztec/telemetry-client": "0.81.0",
+    "@aztec/world-state": "0.81.0",
     "levelup": "^5.1.1",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
@@ -76,9 +76,9 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.80.0",
-    "@aztec/merkle-tree": "0.80.0",
-    "@aztec/noir-contracts.js": "0.80.0",
+    "@aztec/kv-store": "0.81.0",
+    "@aztec/merkle-tree": "0.81.0",
+    "@aztec/noir-contracts.js": "0.81.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/levelup": "^5.1.3",

package/src/common/db_interfaces.ts

@@ -2,7 +2,7 @@ import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 
 import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
@@ -10,7 +10,7 @@ import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 /**
  * Database interface for providing access to public state.
  */
-export interface PublicStateDB {
+export interface PublicStateDBInterface {
   /**
    * Reads a value from public storage, returning zero if none.
    * @param contract - Owner of the storage.
@@ -31,19 +31,40 @@ export interface PublicStateDB {
 /**
  * Database interface for providing access to public contract data.
  */
-export interface PublicContractsDB {
+export interface PublicContractsDBInterface {
   /**
    * Returns a publicly deployed contract instance.
    * @param address - Address of the contract.
+   * @param blockNumber - The block number at which to retrieve the contract instance.
    * @returns The contract instance or undefined if not found.
    */
-  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+  getContractInstance(address: AztecAddress, blockNumber: number): Promise<ContractInstanceWithAddress | undefined>;
 
+  /**
+   * Returns a publicly deployed contract class.
+   * @param contractClassId - ID of the contract class.
+   * @returns The contract class or undefined if not found
+   */
+  getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
+
+  /**
+   * Returns the commitment to the bytecode of a contract class.
+   * @param contractClassId - ID of the contract class.
+   * @returns The commitment to the bytecode or undefined if not found.
+   */
+  getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
+
+  /**
+   * Returns the function name of a contract's function given its selector.
+   * @param contractAddress - Address of the contract.
+   * @param selector - Selector of the function.
+   * @returns The name of the function or undefined if not found.
+   */
   getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }
 
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */
-export interface CommitmentsDB {
+export interface CommitmentsDBInterface {
   /**
    * Fetches a message from the db, given its key.
    * @param contractAddress - Address of a contract by which the message was emitted.

package/src/common/debug_fn_name.ts

@@ -2,10 +2,10 @@ import type { Fr } from '@aztec/foundation/fields';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { WorldStateDB } from '../public/public_db_sources.js';
+import type { PublicContractsDBInterface } from './db_interfaces.js';
 
 export async function getPublicFunctionDebugName(
-  db: WorldStateDB,
+  db: PublicContractsDBInterface,
   contractAddress: AztecAddress,
   calldata: Fr[],
 ): Promise<string> {

package/src/private/acvm/deserialize.ts

@@ -1,4 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
+import { hexToBuffer } from '@aztec/foundation/string';
 
 import type { ACVMField, ACVMWitness } from './acvm_types.js';
 
@@ -41,6 +42,24 @@ export function fromBoundedVec(storage: ACVMField[], length: ACVMField): Fr[] {
   return storage.slice(0, frToNumber(fromACVMField(length))).map(fromACVMField);
 }
 
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ACVMField 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: ACVMField[], length: ACVMField, 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, frToNumber(fromACVMField(length)));
+  return Buffer.concat(boundedStorage.map(str => hexToBuffer(str).subarray(-uintByteSize)));
+}
+
 /**
  * Transforms a witness map to its field elements.
  * @param witness - The witness to extract from.
@@ -50,3 +69,17 @@ export function witnessMapToFields(witness: ACVMWitness): Fr[] {
   const sortedKeys = [...witness.keys()].sort((a, b) => a - b);
   return sortedKeys.map(key => witness.get(key)!).map(fromACVMField);
 }
+
+/**
+ * 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 A buffer where each byte is correctly represented as a single byte in the buffer.
+ * Copy of the function in txe/src/util/encoding.ts.
+ */
+export function fromUintArray(obj: ACVMField[], uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}

package/src/private/acvm/oracle/oracle.ts

@@ -1,12 +1,19 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ContractClassLog, LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
 import type { ACVMField } from '../acvm_types.js';
-import { frToBoolean, frToNumber, fromACVMField, fromBoundedVec } from '../deserialize.js';
-import { toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
+import {
+  frToBoolean,
+  frToNumber,
+  fromACVMField,
+  fromBoundedVec,
+  fromUintArray,
+  fromUintBoundedVec,
+} from '../deserialize.js';
+import { bufferToBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
 import type { TypedOracle } from './typed_oracle.js';
 
 /**
@@ -452,4 +459,31 @@ export class Oracle {
       frToNumber(fromACVMField(numEntries)),
     );
   }
+
+  async aes128Decrypt(
+    ciphertextBVecStorage: ACVMField[],
+    [ciphertextLength]: ACVMField[],
+    iv: ACVMField[],
+    symKey: ACVMField[],
+  ): Promise<(ACVMField | ACVMField[])[]> {
+    const ciphertext = fromUintBoundedVec(ciphertextBVecStorage, ciphertextLength, 8);
+    const ivBuffer = fromUintArray(iv, 8);
+    const symKeyBuffer = fromUintArray(symKey, 8);
+
+    const plaintext = await this.typedOracle.aes128Decrypt(ciphertext, ivBuffer, symKeyBuffer);
+    return bufferToBoundedVec(plaintext, ciphertextBVecStorage.length);
+  }
+
+  async getSharedSecret(
+    [address]: ACVMField[],
+    [ephPKField0]: ACVMField[],
+    [ephPKField1]: ACVMField[],
+    [ephPKField2]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const secret = await this.typedOracle.getSharedSecret(
+      AztecAddress.fromField(fromACVMField(address)),
+      Point.fromFields([ephPKField0, ephPKField1, ephPKField2].map(fromACVMField)),
+    );
+    return secret.toFields().map(toACVMField);
+  }
 }

package/src/private/acvm/oracle/typed_oracle.ts

@@ -1,5 +1,5 @@
 import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -256,4 +256,8 @@ export abstract class TypedOracle {
   aes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer> {
     return Promise.reject(new OracleMethodNotAvailableError('aes128Decrypt'));
   }
+
+  getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
+    return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
+  }
 }

package/src/private/acvm/serialize.ts

@@ -58,3 +58,31 @@ export function toACVMWitness(witnessStartIndex: number, fields: Parameters<type
     return witness;
   }, new Map<number, ACVMField>());
 }
+
+export function bufferToU8Array(buffer: Buffer): ACVMField[] {
+  return Array.from(buffer).map(byte => toACVMField(BigInt(byte)));
+}
+
+export function bufferToBoundedVec(buffer: Buffer, maxLen: number): [ACVMField[], ACVMField] {
+  const u8Array = bufferToU8Array(buffer);
+  return arrayToBoundedVec(u8Array, maxLen);
+}
+
+/**
+ * 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 bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+  const lengthDiff = maxLen - bVecStorage.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(toACVMField(BigInt(0)));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [storage, len];
+}

package/src/private/execution_data_provider.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr, Point } from '@aztec/foundation/fields';
 import type { FunctionArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
@@ -9,7 +9,7 @@ import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
-import type { CommitmentsDB } from '../common/db_interfaces.js';
+import type { CommitmentsDBInterface } from '../common/db_interfaces.js';
 import type { NoteData } from './acvm/index.js';
 
 /**
@@ -33,7 +33,7 @@ export class ContractClassNotFoundError extends Error {
 /**
  * The interface for the data layer required to perform private and unconstrained execution.
  */
-export interface ExecutionDataProvider extends CommitmentsDB {
+export interface ExecutionDataProvider extends CommitmentsDBInterface {
   /**
    * Returns a contract instance associated with an address, if available.
    * @param address - Address.
@@ -239,10 +239,11 @@ export interface ExecutionDataProvider extends CommitmentsDB {
 
   /**
    * Processes the tagged logs returned by syncTaggedLogs by decrypting them and storing them in the database.
+   * @param contractAddress - The address of the contract that emitted the logs.
    * @param logs - The logs to process.
    * @param recipient - The recipient of the logs.
    */
-  processTaggedLogs(logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
+  processTaggedLogs(contractAddress: AztecAddress, 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`
@@ -320,4 +321,12 @@ export interface ExecutionDataProvider extends CommitmentsDB {
    * @param numEntries - The number of entries to copy.
    */
   copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+
+  /**
+   * Retrieves the shared secret for a given address and ephemeral public key.
+   * @param address - The address to get the secret for.
+   * @param ephPk - The ephemeral public key to get the secret for.
+   * @returns The secret for the given address.
+   */
+  getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
 }

package/src/private/private_execution_oracle.ts

@@ -606,7 +606,11 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
       this.scopes,
     );
     for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+      await this.executionDataProvider.processTaggedLogs(
+        this.contractAddress,
+        taggedLogs,
+        AztecAddress.fromString(recipient),
+      );
     }
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);

package/src/private/unconstrained_execution_oracle.ts

@@ -1,5 +1,5 @@
 import { Aes128 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -23,7 +23,7 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
     protected readonly contractAddress: AztecAddress,
     /** List of transient auth witnesses to be used during this simulation */
     protected readonly authWitnesses: AuthWitness[],
-    protected readonly capsules: Capsule[],
+    protected readonly capsules: Capsule[], // TODO(#12425): Rename to transientCapsules
     protected readonly executionDataProvider: ExecutionDataProvider,
     protected log = createLogger('simulator:client_view_context'),
     protected readonly scopes?: AztecAddress[],
@@ -288,7 +288,11 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
     );
 
     for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+      await this.executionDataProvider.processTaggedLogs(
+        this.contractAddress,
+        taggedLogs,
+        AztecAddress.fromString(recipient),
+      );
     }
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
@@ -339,6 +343,7 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
       throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
     return (
+      // TODO(#12425): On the following line, the pertinent capsule gets overshadowed by the transient one. Tackle this.
       this.capsules.find(c => c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ??
       (await this.executionDataProvider.loadCapsule(this.contractAddress, slot))
     );
@@ -370,4 +375,8 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
     const aes128 = new Aes128();
     return aes128.decryptBufferCBC(ciphertext, iv, symKey);
   }
+
+  public override getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
+    return this.executionDataProvider.getSharedSecret(address, ephPk);
+  }
 }

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -16,7 +16,8 @@ import {
   resolveContractAssertionMessage,
 } from '../../avm/fixtures/index.js';
 import { AvmPersistableStateManager } from '../../avm/journal/journal.js';
-import { WorldStateDB } from '../../public_db_sources.js';
+import { DEFAULT_BLOCK_NUMBER } from '../../fixtures/public_tx_simulation_tester.js';
+import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
@@ -41,16 +42,18 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
   static async create(): Promise<AvmSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+    const treesDB = new PublicTreesDB(merkleTrees);
+    const contractsDB = new PublicContractsDB(contractDataSource);
     const trace = new SideEffectTrace();
     const firstNullifier = new Fr(420000);
-    // FIXME: merkle ops should work, but I'm seeing frequent (but inconsistent) bytecode retrieval
-    // failures on 2nd call to simulateCall with merkle ops on
+
     const stateManager = AvmPersistableStateManager.create(
-      worldStateDB,
+      treesDB,
+      contractsDB,
       trace,
       /*doMerkleOperations=*/ false,
       firstNullifier,
+      DEFAULT_BLOCK_NUMBER,
     );
     return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
   }

package/src/public/avm/fixtures/index.ts

@@ -23,7 +23,7 @@ import {
 import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 import { GasFees } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { deriveKeys } from '@aztec/stdlib/keys';
 import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
@@ -32,7 +32,8 @@ import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
 import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
-import type { WorldStateDB } from '../../public_db_sources.js';
+import { DEFAULT_BLOCK_NUMBER } from '../../fixtures/public_tx_simulation_tester.js';
+import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
 import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
 import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
@@ -65,23 +66,25 @@ export function initContext(overrides?: {
 
 /** Creates an empty state manager with mocked host storage. */
 export function initPersistableStateManager(overrides?: {
-  worldStateDB?: WorldStateDB;
+  treesDB?: PublicTreesDB;
+  contractsDB?: PublicContractsDB;
   trace?: PublicSideEffectTraceInterface;
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
   doMerkleOperations?: boolean;
-  db?: MerkleTreeWriteOperations;
   firstNullifier?: Fr;
+  blockNumber?: number;
 }): AvmPersistableStateManager {
-  const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
+  const treesDB = overrides?.treesDB || mock<PublicTreesDB>();
   return new AvmPersistableStateManager(
-    worldStateDB,
+    treesDB,
+    overrides?.contractsDB || mock<PublicContractsDB>(),
     overrides?.trace || mock<PublicSideEffectTraceInterface>(),
-    overrides?.publicStorage || new PublicStorage(worldStateDB),
-    overrides?.nullifiers || new NullifierManager(worldStateDB),
-    overrides?.doMerkleOperations || false,
-    overrides?.db || mock<MerkleTreeWriteOperations>(),
     overrides?.firstNullifier || new Fr(27),
+    overrides?.blockNumber || DEFAULT_BLOCK_NUMBER,
+    overrides?.doMerkleOperations || false,
+    overrides?.publicStorage,
+    overrides?.nullifiers,
   );
 }
 
@@ -282,17 +285,20 @@ export async function createContractClassAndInstance(
   );
 
   const constructorAbi = getContractFunctionArtifact('constructor', contractArtifact);
+  const { publicKeys } = await deriveKeys(Fr.random());
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
   const contractInstance =
     originalContractClassId === undefined
       ? await makeContractInstanceFromClassId(contractClass.id, seed, {
           deployer,
           initializationHash,
+          publicKeys,
         })
       : await makeContractInstanceFromClassId(originalContractClassId, seed, {
           deployer,
           initializationHash,
           currentClassId: contractClass.id,
+          publicKeys,
         });
 
   const contractAddressNullifier = await siloNullifier(

package/src/public/avm/fixtures/simple_contract_data_source.ts

@@ -2,12 +2,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type {
-  ContractClassPublic,
-  ContractDataSource,
-  ContractInstanceWithAddress,
-  PublicFunction,
-} from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
 
@@ -50,10 +45,6 @@ export class SimpleContractDataSource implements ContractDataSource {
 
   /////////////////////////////////////////////////////////////
   // ContractDataSource function implementations
-  getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
-    throw new Error('Method not implemented.');
-  }
-
   getBlockNumber(): Promise<number> {
     throw new Error('Method not implemented.');
   }