@aztec/simulator 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/public/avm/serialization/bytecode_serialization.ts

@@ -1,215 +0,0 @@
-import { type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import {
-  AvmExecutionError,
-  AvmParsingError,
-  InvalidOpcodeError,
-  InvalidProgramCounterError,
-  InvalidTagValueError,
-  duringInstrFetch,
-} from '../errors.js';
-import {
-  Add,
-  And,
-  Call,
-  CalldataCopy,
-  Cast,
-  DebugLog,
-  Div,
-  EcAdd,
-  EmitNoteHash,
-  EmitNullifier,
-  EmitPublicLog,
-  Eq,
-  FieldDiv,
-  GetContractInstance,
-  GetEnvVar,
-  Instruction,
-  InternalCall,
-  InternalReturn,
-  Jump,
-  JumpI,
-  KeccakF1600,
-  L1ToL2MessageExists,
-  Lt,
-  Lte,
-  Mov,
-  Mul,
-  Not,
-  NoteHashExists,
-  NullifierExists,
-  Or,
-  Poseidon2,
-  Return,
-  ReturndataCopy,
-  ReturndataSize,
-  Revert,
-  SLoad,
-  SStore,
-  SendL2ToL1Message,
-  Set,
-  Sha256Compression,
-  Shl,
-  Shr,
-  StaticCall,
-  Sub,
-  SuccessCopy,
-  ToRadixBE,
-  Xor,
-} from '../opcodes/index.js';
-import { BufferCursor } from './buffer_cursor.js';
-import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
-
-export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
-
-export interface Deserializable {
-  deserialize: InstructionDeserializer;
-}
-
-export type InstructionSet = Map<Opcode, InstructionDeserializer>;
-export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
-  [Opcode.ADD_8, Add.as(Add.wireFormat8).fromBuffer],
-  [Opcode.ADD_16, Add.as(Add.wireFormat16).fromBuffer],
-  [Opcode.SUB_8, Sub.as(Sub.wireFormat8).fromBuffer],
-  [Opcode.SUB_16, Sub.as(Sub.wireFormat16).fromBuffer],
-  [Opcode.MUL_8, Mul.as(Mul.wireFormat8).fromBuffer],
-  [Opcode.MUL_16, Mul.as(Mul.wireFormat16).fromBuffer],
-  [Opcode.DIV_8, Div.as(Div.wireFormat8).fromBuffer],
-  [Opcode.DIV_16, Div.as(Div.wireFormat16).fromBuffer],
-  [Opcode.FDIV_8, FieldDiv.as(FieldDiv.wireFormat8).fromBuffer],
-  [Opcode.FDIV_16, FieldDiv.as(FieldDiv.wireFormat16).fromBuffer],
-  [Opcode.EQ_8, Eq.as(Eq.wireFormat8).fromBuffer],
-  [Opcode.EQ_16, Eq.as(Eq.wireFormat16).fromBuffer],
-  [Opcode.LT_8, Lt.as(Lt.wireFormat8).fromBuffer],
-  [Opcode.LT_16, Lt.as(Lt.wireFormat16).fromBuffer],
-  [Opcode.LTE_8, Lte.as(Lte.wireFormat8).fromBuffer],
-  [Opcode.LTE_16, Lte.as(Lte.wireFormat16).fromBuffer],
-  [Opcode.AND_8, And.as(And.wireFormat8).fromBuffer],
-  [Opcode.AND_16, And.as(And.wireFormat16).fromBuffer],
-  [Opcode.OR_8, Or.as(Or.wireFormat8).fromBuffer],
-  [Opcode.OR_16, Or.as(Or.wireFormat16).fromBuffer],
-  [Opcode.XOR_8, Xor.as(Xor.wireFormat8).fromBuffer],
-  [Opcode.XOR_16, Xor.as(Xor.wireFormat16).fromBuffer],
-  [Opcode.NOT_8, Not.as(Not.wireFormat8).fromBuffer],
-  [Opcode.NOT_16, Not.as(Not.wireFormat16).fromBuffer],
-  [Opcode.SHL_8, Shl.as(Shl.wireFormat8).fromBuffer],
-  [Opcode.SHL_16, Shl.as(Shl.wireFormat16).fromBuffer],
-  [Opcode.SHR_8, Shr.as(Shr.wireFormat8).fromBuffer],
-  [Opcode.SHR_16, Shr.as(Shr.wireFormat16).fromBuffer],
-  [Opcode.CAST_8, Cast.as(Cast.wireFormat8).fromBuffer],
-  [Opcode.CAST_16, Cast.as(Cast.wireFormat16).fromBuffer],
-  // Execution Environment
-  [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).fromBuffer],
-  [CalldataCopy.opcode, Instruction.fromBuffer.bind(CalldataCopy)],
-  [SuccessCopy.opcode, Instruction.fromBuffer.bind(SuccessCopy)],
-  [Opcode.RETURNDATASIZE, Instruction.fromBuffer.bind(ReturndataSize)],
-  [Opcode.RETURNDATACOPY, Instruction.fromBuffer.bind(ReturndataCopy)],
-
-  // Machine State - Internal Control Flow
-  [Jump.opcode, Instruction.fromBuffer.bind(Jump)],
-  [JumpI.opcode, Instruction.fromBuffer.bind(JumpI)],
-  [InternalCall.opcode, Instruction.fromBuffer.bind(InternalCall)],
-  [InternalReturn.opcode, Instruction.fromBuffer.bind(InternalReturn)],
-  [Opcode.SET_8, Set.as(Set.wireFormat8).fromBuffer],
-  [Opcode.SET_16, Set.as(Set.wireFormat16).fromBuffer],
-  [Opcode.SET_32, Set.as(Set.wireFormat32).fromBuffer],
-  [Opcode.SET_64, Set.as(Set.wireFormat64).fromBuffer],
-  [Opcode.SET_128, Set.as(Set.wireFormat128).fromBuffer],
-  [Opcode.SET_FF, Set.as(Set.wireFormatFF).fromBuffer],
-  [Opcode.MOV_8, Mov.as(Mov.wireFormat8).fromBuffer],
-  [Opcode.MOV_16, Mov.as(Mov.wireFormat16).fromBuffer],
-
-  // World State
-  [SLoad.opcode, Instruction.fromBuffer.bind(SLoad)], // Public Storage
-  [SStore.opcode, Instruction.fromBuffer.bind(SStore)], // Public Storage
-  [NoteHashExists.opcode, Instruction.fromBuffer.bind(NoteHashExists)], // Notes & Nullifiers
-  [EmitNoteHash.opcode, Instruction.fromBuffer.bind(EmitNoteHash)], // Notes & Nullifiers
-  [NullifierExists.opcode, Instruction.fromBuffer.bind(NullifierExists)], // Notes & Nullifiers
-  [EmitNullifier.opcode, Instruction.fromBuffer.bind(EmitNullifier)], // Notes & Nullifiers
-  [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
-
-  // Accrued Substate
-  [EmitPublicLog.opcode, Instruction.fromBuffer.bind(EmitPublicLog)],
-  [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
-  [GetContractInstance.opcode, Instruction.fromBuffer.bind(GetContractInstance)],
-
-  // Control Flow - Contract Calls
-  [Call.opcode, Instruction.fromBuffer.bind(Call)],
-  [StaticCall.opcode, Instruction.fromBuffer.bind(StaticCall)],
-  [Return.opcode, Instruction.fromBuffer.bind(Return)],
-  [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).fromBuffer],
-  [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).fromBuffer],
-
-  // Misc
-  [DebugLog.opcode, Instruction.fromBuffer.bind(DebugLog)],
-
-  // Gadgets
-  [EcAdd.opcode, Instruction.fromBuffer.bind(EcAdd)],
-  [Poseidon2.opcode, Instruction.fromBuffer.bind(Poseidon2)],
-  [Sha256Compression.opcode, Instruction.fromBuffer.bind(Sha256Compression)],
-  [KeccakF1600.opcode, Instruction.fromBuffer.bind(KeccakF1600)],
-
-  // Conversions
-  [ToRadixBE.opcode, Instruction.fromBuffer.bind(ToRadixBE)],
-]);
-
-/**
- * Serializes an array of instructions to bytecode.
- */
-export function encodeToBytecode(instructions: Bufferable[]): Buffer {
-  return serializeToBuffer(instructions);
-}
-
-// For testing only
-export function decodeFromBytecode(bytecode: Buffer, instructionSet: InstructionSet = INSTRUCTION_SET): Instruction[] {
-  const instructions: Instruction[] = [];
-  let pc = 0;
-  while (pc < bytecode.length) {
-    const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
-    instructions.push(instruction);
-    pc += bytesConsumed;
-  }
-  return instructions;
-}
-
-// Returns the instruction and the number of bytes consumed.
-export function decodeInstructionFromBytecode(
-  bytecode: Buffer,
-  pc: number,
-  instructionSet: InstructionSet = INSTRUCTION_SET,
-): [Instruction, number] {
-  if (pc >= bytecode.length) {
-    throw new InvalidProgramCounterError(pc, bytecode.length - 1);
-  }
-
-  try {
-    const cursor = new BufferCursor(bytecode, pc);
-    const startingPosition = cursor.position();
-    const opcode: number = cursor.bufferAtPosition().readUint8(); // peek.
-
-    if (opcode > MAX_OPCODE_VALUE) {
-      throw new InvalidOpcodeError(
-        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes (at PC ${pc}).`,
-      );
-    }
-
-    const instructionDeserializerOrUndef = instructionSet.get(opcode);
-    if (instructionDeserializerOrUndef === undefined) {
-      throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
-    }
-
-    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
-
-    const instruction = instructionDeserializer(cursor);
-    return [instruction, cursor.position() - startingPosition];
-  } catch (error) {
-    if (error instanceof InvalidTagValueError || error instanceof InvalidOpcodeError) {
-      throw duringInstrFetch(error, pc);
-    } else if (error instanceof AvmExecutionError) {
-      throw new AvmParsingError(`Instruction parsing error at pc ${pc}: ${error.message}`);
-    } else {
-      const msg = error instanceof Error ? `: ${error.message}` : '';
-      throw new AvmParsingError(`Instruction fetching error at pc ${pc}${msg}`);
-    }
-  }
-}

package/src/public/avm/serialization/instruction_serialization.ts

@@ -1,249 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-
-import { strict as assert } from 'assert';
-
-import { TaggedMemory } from '../avm_memory_types.js';
-import { BufferCursor } from './buffer_cursor.js';
-
-/**
- * All AVM opcodes. (Keep in sync with cpp counterpart code avm_opcode.hpp and rs in opcodes.rs).
- * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
- */
-export enum Opcode {
-  // Compute
-  ADD_8,
-  ADD_16,
-  SUB_8,
-  SUB_16,
-  MUL_8,
-  MUL_16,
-  DIV_8,
-  DIV_16,
-  FDIV_8,
-  FDIV_16,
-  EQ_8,
-  EQ_16,
-  LT_8,
-  LT_16,
-  LTE_8,
-  LTE_16,
-  AND_8,
-  AND_16,
-  OR_8,
-  OR_16,
-  XOR_8,
-  XOR_16,
-  NOT_8,
-  NOT_16,
-  SHL_8,
-  SHL_16,
-  SHR_8,
-  SHR_16,
-  CAST_8,
-  CAST_16,
-  // Execution environment
-  GETENVVAR_16,
-  CALLDATACOPY,
-  SUCCESSCOPY,
-  RETURNDATASIZE,
-  RETURNDATACOPY,
-  // Control flow
-  JUMP_32,
-  JUMPI_32,
-  INTERNALCALL,
-  INTERNALRETURN,
-  // Memory
-  SET_8,
-  SET_16,
-  SET_32,
-  SET_64,
-  SET_128,
-  SET_FF,
-  MOV_8,
-  MOV_16,
-  // World state
-  SLOAD,
-  SSTORE,
-  NOTEHASHEXISTS,
-  EMITNOTEHASH,
-  NULLIFIEREXISTS,
-  EMITNULLIFIER,
-  L1TOL2MSGEXISTS,
-  GETCONTRACTINSTANCE,
-  EMITPUBLICLOG,
-  SENDL2TOL1MSG,
-  // External calls
-  CALL,
-  STATICCALL,
-  RETURN,
-  REVERT_8,
-  REVERT_16,
-  // Misc
-  DEBUGLOG,
-  // Gadgets
-  POSEIDON2,
-  SHA256COMPRESSION,
-  KECCAKF1600,
-  ECADD,
-  // Conversion
-  TORADIXBE,
-}
-
-export const MAX_OPCODE_VALUE = Math.max(
-  ...Object.values(Opcode)
-    .map(k => +k)
-    .filter(k => !isNaN(k)),
-);
-
-// Possible types for an instruction's operand in its wire format.
-// The counterpart cpp file is: vm2/simulation/lib/serialization.hpp.
-export enum OperandType {
-  UINT8,
-  UINT16,
-  UINT32,
-  UINT64,
-  UINT128,
-  FF,
-  TAG,
-}
-
-// Define a type that represents the possible types of the deserialized values.
-type DeserializedValue = number | bigint;
-
-type OperandNativeType = number | bigint;
-type OperandWriter = (value: any) => void;
-
-// Specifies how to read and write each operand type.
-const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNativeType, OperandWriter]>([
-  [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
-  [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
-  [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
-  [OperandType.UINT64, [8, readUint64BE, writeUint64BE]],
-  [OperandType.UINT128, [16, readUint128BE, writeUint128BE]],
-  [OperandType.FF, [32, readUint254BE, writeUint254BE]],
-  [OperandType.TAG, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
-]);
-
-/**
- * Returns the size of an operand in bytes.
- * Should not be called with unknown operand types.
- * @param operandType
- * @returns number size in bytes
- * @throws AssertionError if the operand type is unknown
- */
-export function getOperandSize(operandType: OperandType): number {
-  assert(OPERAND_SPEC.has(operandType), `Unknown operand type: ${operandType}`);
-  return OPERAND_SPEC.get(operandType)![0];
-}
-
-function readUintBE(buf: Buffer, offset: number, totalBytes: number): bigint {
-  let value: bigint = 0n;
-  for (let i = 0; i < totalBytes; ++i) {
-    value <<= 8n;
-    value |= BigInt(buf.readUint8(i + offset));
-  }
-  return value;
-}
-
-function writeUintBE(buf: Buffer, value: bigint, totalBytes: number): void {
-  for (let offset = totalBytes - 1; offset >= 0; --offset) {
-    buf.writeUint8(Number(value & 0xffn), offset);
-    value >>= 8n;
-  }
-}
-
-function readUint64BE(this: Buffer, offset: number): bigint {
-  return readUintBE(this, offset, 8);
-}
-
-function writeUint64BE(this: Buffer, value: bigint): void {
-  writeUintBE(this, value, 8);
-}
-
-function readUint254BE(this: Buffer, offset: number): bigint {
-  let value = readUintBE(this, offset, 32);
-
-  // In circuit, we only support values up to Fr.MODULUS and any deserialized value
-  // would naturally undergo a modulus reduction.
-  if (value >= Fr.MODULUS) {
-    value = value % Fr.MODULUS;
-  }
-
-  return value;
-}
-
-function writeUint254BE(this: Buffer, value: bigint): void {
-  writeUintBE(this, value, 32);
-}
-
-function readUint128BE(this: Buffer, offset: number): bigint {
-  return readUintBE(this, offset, 16);
-}
-
-function writeUint128BE(this: Buffer, value: bigint): void {
-  writeUintBE(this, value, 16);
-}
-
-/**
- * Reads an array of operands from a buffer.
- * @param cursor Buffer to read from. Might be longer than needed.
- * @param operands Specification of the operand types.
- * @returns An array as big as {@code operands}, with the converted TS values.
- */
-export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): DeserializedValue[] {
-  const argValues: DeserializedValue[] = [];
-  if (Buffer.isBuffer(cursor)) {
-    cursor = new BufferCursor(cursor);
-  }
-
-  for (const opType of operands) {
-    const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
-    const value = reader.call(cursor.buffer(), cursor.position());
-    argValues.push(value);
-    cursor.advance(sizeBytes);
-  }
-
-  // We first want to detect other parsing errors (e.g., instruction size
-  // is longer than remaining bytes) first and therefore tag validation is done after completion
-  // of parsing above. Order of errors need to match with circuit.
-  for (let i = 0; i < operands.length; i++) {
-    if (operands[i] === OperandType.TAG) {
-      // We parsed a single byte (readUInt8()) and therefore value is of number type (not bigint)
-      // We need to cast to number because checkIsValidTag expects a number.
-      TaggedMemory.checkIsValidTag(Number(argValues[i] ?? 0));
-    }
-  }
-
-  return argValues;
-}
-
-/**
- * Serializes a class using the specified operand types.
- * More specifically, this serializes {@code [cls.constructor.opcode, ...Object.values(cls)]}.
- * Observe in particular that:
- *   (1) the first operand type specified must correspond to the opcode;
- *   (2) the rest of the operand types must be specified in the order returned by {@code Object.values()}.
- * @param operands Type specification for the values to be serialized.
- * @param cls The class to be serialized.
- * @returns
- */
-export function serializeAs(operands: OperandType[], opcode: Opcode, cls: any): Buffer {
-  const chunks: Buffer[] = [];
-
-  const rawClassValues: any[] = [opcode, ...Object.values(cls)];
-  assert(
-    rawClassValues.length === operands.length,
-    `Got ${rawClassValues.length} values but only ${operands.length} serialization operands are specified!`,
-  );
-  const classValues = rawClassValues as OperandNativeType[];
-
-  for (let i = 0; i < operands.length; i++) {
-    const opType = operands[i];
-    const [sizeBytes, _reader, writer] = OPERAND_SPEC.get(opType)!;
-    const buf = Buffer.alloc(sizeBytes);
-    writer.call(buf, classValues[i]);
-    chunks.push(buf);
-  }
-
-  return Buffer.concat(chunks);
-}

package/src/public/avm/test_utils.ts

@@ -1,64 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-
-import type { jest } from '@jest/globals';
-import { mock } from 'jest-mock-extended';
-
-import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
-import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
-
-export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
-  (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
-    nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
-  );
-}
-
-export function mockStorageRead(worldStateDB: PublicTreesDB, value: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockResolvedValue(value);
-}
-
-export function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number) {
-  (mockedTrace as jest.Mocked<PublicSideEffectTraceInterface>).getNoteHashCount.mockReturnValue(count);
-}
-
-export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorage: Map<bigint, Fr>) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockImplementation((_address, slot) =>
-    Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
-  );
-}
-
-export function mockGetNoteHash(worldStateDB: PublicTreesDB, _leafIndex: bigint, value?: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
-    if (index == _leafIndex && value) {
-      return Promise.resolve(value);
-    } else {
-      return Promise.resolve(Fr.ZERO);
-    }
-  });
-}
-
-export function mockCheckNullifierExists(worldStateDB: PublicTreesDB, exists: boolean, _ignoredValue?: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).checkNullifierExists.mockResolvedValue(exists);
-}
-
-export function mockGetL1ToL2LeafValue(worldStateDB: PublicTreesDB, leafIndex: bigint, value?: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
-    if (index == leafIndex && value) {
-      return Promise.resolve(value);
-    } else {
-      return Promise.resolve(Fr.ZERO!);
-    }
-  });
-}
-
-export function mockGetContractInstance(contractsDB: PublicContractsDB, contractInstance: ContractInstanceWithAddress) {
-  (contractsDB as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
-}
-
-export function mockGetContractClass(contractsDB: PublicContractsDB, contractClass: ContractClassPublic) {
-  (contractsDB as jest.Mocked<PublicContractsDB>).getContractClass.mockResolvedValue(contractClass);
-}
-
-export function mockGetBytecodeCommitment(contractsDB: PublicContractsDB, commitment: Fr) {
-  (contractsDB as jest.Mocked<PublicContractsDB>).getBytecodeCommitment.mockResolvedValue(commitment);
-}

package/src/public/debug_fn_name.ts

@@ -1,52 +0,0 @@
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import type { CallData } from './avm/calldata.js';
-import type { PublicContractsDBInterface } from './db_interfaces.js';
-
-export async function getPublicFunctionDebugName(
-  db: PublicContractsDBInterface,
-  contractAddress: AztecAddress,
-  calldata: CallData,
-): Promise<string> {
-  // Public function is dispatched and therefore the target function is passed in the first argument.
-  const selectorField = calldata.read(0);
-  if (!selectorField) {
-    return `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
-  }
-  const fallbackName = `<calldata[0]:${selectorField.toString()}> (Contract Address: ${contractAddress})`;
-  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
-  if (!selector) {
-    return fallbackName;
-  }
-  return (await db.getDebugFunctionName(contractAddress, selector)) ?? fallbackName;
-}
-
-/**
- * Get the function selector and optional debug name for a public function.
- * Returns the selector and name separately, with name only populated if a debug name is available.
- * @param db - The contracts database
- * @param contractAddress - The contract address
- * @param calldata - The calldata (selector is in calldata[0])
- * @returns An object with functionSelector (always if calldata[0] exists) and functionName (only if debug name found)
- */
-export async function getPublicFunctionSelectorAndName(
-  db: PublicContractsDBInterface,
-  contractAddress: AztecAddress,
-  calldata: CallData,
-): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
-  // Public function is dispatched and therefore the target function is passed in the first argument.
-  const selectorField = calldata.read(0);
-  if (!selectorField) {
-    return {};
-  }
-  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
-  if (!selector) {
-    return {};
-  }
-  const debugName = await db.getDebugFunctionName(contractAddress, selector);
-  return {
-    functionSelector: selector,
-    functionName: debugName ?? undefined,
-  };
-}