@aztec/simulator 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/public/avm_simulator_pool.ts

@@ -0,0 +1,226 @@
+import { AvmService } from '@aztec/bb-avm-sim';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
+import { CdbIpcServer } from './cdb_ipc_server.js';
+
+export interface AvmSimulatorPoolOptions {
+  /** Maximum number of concurrent AVM processes. If not set, defaults to AVM_MAX_CONCURRENT_SIMULATIONS env var or 4. */
+  maxSize?: number;
+  /** Path to the bb-avm-sim binary. If omitted, the generated package resolves it. */
+  avmBinaryPath?: string;
+  /** IPC path for the shared WSDB server. */
+  wsdbIpcPath: string;
+  /** Optional logger function for AVM process output. */
+  logger?: (msg: string) => void;
+}
+
+/**
+ * A raw handle to a single bb-avm-sim process: it runs a serialized simulation and connects back to the
+ * shared CDB/WSDB servers for state, but is unaware of which fork's contract data it is reading — that is
+ * routed by the fork id baked into the input buffer.
+ */
+interface AvmProcessHandle {
+  simulate(inputBuffer: Uint8Array, signal?: AbortSignal): Promise<Uint8Array>;
+  simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
+  destroy(): Promise<void>;
+}
+
+/**
+ * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim processes plus the CDB server that
+ * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
+ * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
+ * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
+ * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
+ */
+export class AvmSimulatorPool implements AvmSimulator {
+  private slots: Array<AvmProcessHandle | null> = [];
+  private available: number[] = [];
+  private waiters: Array<{ resolve: (simulator: AvmProcessHandle) => void; reject: (error: Error) => void }> = [];
+  private createdCount = 0;
+  private log: Logger;
+  private maxSize: number;
+  private cdbServer: CdbIpcServer;
+
+  constructor(private options: AvmSimulatorPoolOptions) {
+    this.log = createLogger('simulator:avm-pool');
+    this.maxSize = options.maxSize ?? parseInt(process.env.AVM_MAX_CONCURRENT_SIMULATIONS ?? '4', 10);
+    this.cdbServer = new CdbIpcServer();
+  }
+
+  static async spawn(options: AvmSimulatorPoolOptions): Promise<AvmSimulatorPool> {
+    const pool = new AvmSimulatorPool(options);
+    // Always start one process up front so the first simulate() doesn't pay process spawn/connect cost.
+    await pool.prewarm();
+    return pool;
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.destroy();
+  }
+
+  async simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array> {
+    // Register the fork's contracts DB so the C++ AVM's callbacks (which carry this fork id) route to it,
+    // and unregister once the simulation returns — registration is only needed while the call is running.
+    this.cdbServer.registerFork(context.forkId, context.contractsDB, context.timestamp);
+    try {
+      const simulator = await this.checkout();
+      try {
+        return await simulator.simulate(inputBuffer, signal);
+      } finally {
+        this.return(simulator);
+      }
+    } finally {
+      this.cdbServer.unregisterFork(context.forkId);
+    }
+  }
+
+  async simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    // The hinted path makes no contract-data callbacks, so no CDB registration is needed.
+    const simulator = await this.checkout();
+    try {
+      return await simulator.simulateWithHints(inputBuffer);
+    } finally {
+      this.return(simulator);
+    }
+  }
+
+  /** Destroy all AVM processes in the pool and close the CDB server. */
+  async destroy(): Promise<void> {
+    for (const waiter of this.waiters) {
+      waiter.reject(new Error('AVM simulator pool destroyed'));
+    }
+    this.waiters = [];
+
+    const destroyPromises: Promise<void>[] = [];
+    for (const slot of this.slots) {
+      if (slot) {
+        destroyPromises.push(slot.destroy());
+      }
+    }
+    await Promise.all(destroyPromises);
+
+    this.slots = [];
+    this.available = [];
+    this.createdCount = 0;
+    await this.cdbServer.close();
+    this.log.info('AVM simulator pool destroyed');
+  }
+
+  /**
+   * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
+   * first simulate() doesn't pay process spawn/connect cost. Idempotent.
+   */
+  async prewarm(count = 1): Promise<void> {
+    const target = Math.min(count, this.maxSize);
+    const created: AvmProcessHandle[] = [];
+    while (this.createdCount < target) {
+      created.push(await this.createSlot());
+    }
+    // Hand the freshly-spawned processes back to the pool so checkout() reuses them.
+    for (const simulator of created) {
+      this.return(simulator);
+    }
+  }
+
+  /** Check out an AVM process from the pool, blocking until one is free. Caller must return() it when done. */
+  private async checkout(): Promise<AvmProcessHandle> {
+    const idx = this.available.pop();
+    if (idx !== undefined && this.slots[idx]) {
+      return this.slots[idx]!;
+    }
+
+    if (this.createdCount < this.maxSize || (idx !== undefined && !this.slots[idx])) {
+      return await this.createSlot(idx);
+    }
+
+    return new Promise<AvmProcessHandle>((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+
+  /** Return an AVM process to the pool after use. */
+  private return(simulator: AvmProcessHandle): void {
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve(simulator);
+    } else {
+      const idx = this.slots.indexOf(simulator);
+      if (idx >= 0) {
+        this.available.push(idx);
+      }
+    }
+  }
+
+  private async createSlot(reuseIdx?: number): Promise<AvmProcessHandle> {
+    const reuse = reuseIdx !== undefined && reuseIdx < this.slots.length;
+    // Reserve the slot count synchronously, before the async spawn, so concurrent checkouts can't all
+    // observe `createdCount < maxSize` and overshoot the pool (the count is only bumped once control has
+    // yielded on the await). Roll back the reservation if the spawn itself fails.
+    if (!reuse) {
+      this.createdCount++;
+    }
+    let simulator: AvmProcessHandle;
+    try {
+      simulator = await AvmSimulatorProcess.spawn({
+        binaryPath: this.options.avmBinaryPath,
+        wsdbIpcPath: this.options.wsdbIpcPath,
+        cdbIpcPath: this.cdbServer.ipcPath,
+        logger: this.options.logger,
+      });
+    } catch (err) {
+      if (!reuse) {
+        this.createdCount--;
+      }
+      throw err;
+    }
+    if (reuse) {
+      this.slots[reuseIdx!] = simulator;
+    } else {
+      this.slots.push(simulator);
+    }
+    this.log.debug(`Created AVM pool slot (${this.createdCount}/${this.maxSize})`);
+    return simulator;
+  }
+}
+
+class AvmSimulatorProcess implements AvmProcessHandle {
+  private constructor(private service: AvmService) {}
+
+  static async spawn(options: {
+    binaryPath?: string;
+    wsdbIpcPath: string;
+    cdbIpcPath: string;
+    logger?: (msg: string) => void;
+  }): Promise<AvmSimulatorProcess> {
+    const service = await AvmService.spawn({
+      binaryPath: options.binaryPath,
+      transport: 'uds',
+      logger: options.logger,
+      extraArgs: ['--wsdb', options.wsdbIpcPath, '--cdb', options.cdbIpcPath],
+    });
+    return new AvmSimulatorProcess(service);
+  }
+
+  public async simulate(inputBuffer: Uint8Array, signal?: AbortSignal): Promise<Uint8Array> {
+    // Signal the C++ process to stop at its next cancellation checkpoint when the caller aborts.
+    const onAbort = () => this.service.sendProcessSignal('SIGUSR1');
+    if (signal?.aborted) {
+      onAbort();
+    }
+    signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+      return (await this.service.simulate({ inputs: inputBuffer })).result;
+    } finally {
+      signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
+  public async simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    return (await this.service.simulateWithHints({ inputs: inputBuffer })).result;
+  }
+
+  public async destroy(): Promise<void> {
+    await this.service.destroy();
+  }
+}

package/src/public/cdb/generated/api_types.ts

@@ -0,0 +1,457 @@
+// AUTOGENERATED FILE - DO NOT EDIT
+
+/** Schema version hash for compatibility checking */
+export const SCHEMA_HASH = 'ef6a34b441b65d90238d2b3616a763136f5f53f9239ecabe9163ebf9388c89bd';
+
+// Runtime guards for wire types that JS cannot represent natively.
+// TODO: migrate u64 fields to bigint end-to-end and drop these.
+//
+// Decode: msgpackr returns uint64/int64 wire values as bigint once they
+// exceed 32 bits; values must fit in the JS safe integer range.
+function assertU64(value: number | bigint, ctx: string): number {
+  if (typeof value === "bigint") {
+    if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`${ctx}: u64 value ${value} is outside JS safe integer range`);
+    }
+    return Number(value);
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${ctx}: u64 value ${value} is outside JS safe integer range`);
+  }
+  return value;
+}
+
+// Encode: msgpackr encodes JS numbers above 2^32 as float64, which strict
+// u64 decoders reject; route them through bigint so the wire type stays uint.
+function toWireU64(value: number | bigint, ctx: string): number | bigint {
+  const checked = assertU64(value, ctx);
+  return checked > 0xffffffff ? BigInt(checked) : checked;
+}
+
+function assertBin32(value: Uint8Array, ctx: string): Uint8Array {
+  if (value.length !== 32) {
+    throw new Error(`${ctx}: expected 32 bytes, got ${value.length}`);
+  }
+  return value;
+}
+
+// Type aliases for primitive types
+export type AztecAddress = Uint8Array;
+export type ContractClassId = Uint8Array;
+export type ForkId = number;
+export type Fr = Uint8Array;
+export type FunctionSelector = Uint8Array;
+
+// Public interfaces (exported)
+export interface CdbGetContractInstance {
+  address: AztecAddress;
+  forkId: ForkId;
+}
+
+export interface CdbGetContractClass {
+  classId: ContractClassId;
+  forkId: ForkId;
+}
+
+export interface CdbGetBytecodeCommitment {
+  classId: ContractClassId;
+  forkId: ForkId;
+}
+
+export interface CdbGetDebugFunctionName {
+  address: AztecAddress;
+  selector: FunctionSelector;
+  forkId: ForkId;
+}
+
+export interface CdbAddContracts {
+  contractDeploymentData: Uint8Array;
+  forkId: ForkId;
+}
+
+export interface CdbCreateCheckpoint {
+  forkId: ForkId;
+}
+
+export interface CdbCommitCheckpoint {
+  forkId: ForkId;
+}
+
+export interface CdbRevertCheckpoint {
+  forkId: ForkId;
+}
+
+export interface CdbGetContractInstanceResponse {
+  instance: Uint8Array | null;
+}
+
+export interface CdbGetContractClassResponse {
+  contractClass: Uint8Array | null;
+}
+
+export interface CdbGetBytecodeCommitmentResponse {
+  commitment: Fr | null;
+}
+
+export interface CdbGetDebugFunctionNameResponse {
+  name: string | null;
+}
+
+export interface CdbAddContractsResponse {
+
+}
+
+export interface CdbCreateCheckpointResponse {
+
+}
+
+export interface CdbCommitCheckpointResponse {
+
+}
+
+export interface CdbRevertCheckpointResponse {
+
+}
+
+export interface CdbErrorResponse {
+  message: string;
+}
+
+// Private Msgpack interfaces (not exported)
+interface MsgpackCdbGetContractInstance {
+  address: Uint8Array;
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbGetContractClass {
+  classId: Uint8Array;
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbGetBytecodeCommitment {
+  classId: Uint8Array;
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbGetDebugFunctionName {
+  address: Uint8Array;
+  selector: Uint8Array;
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbAddContracts {
+  contractDeploymentData: Uint8Array;
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbCreateCheckpoint {
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbCommitCheckpoint {
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbRevertCheckpoint {
+  forkId: number | bigint;
+}
+
+interface MsgpackCdbGetContractInstanceResponse {
+  instance: Uint8Array | null;
+}
+
+interface MsgpackCdbGetContractClassResponse {
+  contractClass: Uint8Array | null;
+}
+
+interface MsgpackCdbGetBytecodeCommitmentResponse {
+  commitment: Uint8Array | null;
+}
+
+interface MsgpackCdbGetDebugFunctionNameResponse {
+  name: string | null;
+}
+
+interface MsgpackCdbAddContractsResponse {
+
+}
+
+interface MsgpackCdbCreateCheckpointResponse {
+
+}
+
+interface MsgpackCdbCommitCheckpointResponse {
+
+}
+
+interface MsgpackCdbRevertCheckpointResponse {
+
+}
+
+interface MsgpackCdbErrorResponse {
+  message: string;
+}
+
+// Conversion functions (exported)
+export function toCdbGetContractInstance(o: MsgpackCdbGetContractInstance): CdbGetContractInstance {
+  if (o.address === undefined) { throw new Error("Expected address in CdbGetContractInstance deserialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetContractInstance deserialization"); };
+  return {
+    address: assertBin32(o.address, "o.address"),
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbGetContractClass(o: MsgpackCdbGetContractClass): CdbGetContractClass {
+  if (o.classId === undefined) { throw new Error("Expected classId in CdbGetContractClass deserialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetContractClass deserialization"); };
+  return {
+    classId: assertBin32(o.classId, "o.classId"),
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbGetBytecodeCommitment(o: MsgpackCdbGetBytecodeCommitment): CdbGetBytecodeCommitment {
+  if (o.classId === undefined) { throw new Error("Expected classId in CdbGetBytecodeCommitment deserialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetBytecodeCommitment deserialization"); };
+  return {
+    classId: assertBin32(o.classId, "o.classId"),
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbGetDebugFunctionName(o: MsgpackCdbGetDebugFunctionName): CdbGetDebugFunctionName {
+  if (o.address === undefined) { throw new Error("Expected address in CdbGetDebugFunctionName deserialization"); }
+  if (o.selector === undefined) { throw new Error("Expected selector in CdbGetDebugFunctionName deserialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetDebugFunctionName deserialization"); };
+  return {
+    address: assertBin32(o.address, "o.address"),
+    selector: assertBin32(o.selector, "o.selector"),
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbAddContracts(o: MsgpackCdbAddContracts): CdbAddContracts {
+  if (o.contractDeploymentData === undefined) { throw new Error("Expected contractDeploymentData in CdbAddContracts deserialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbAddContracts deserialization"); };
+  return {
+    contractDeploymentData: o.contractDeploymentData,
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbCreateCheckpoint(o: MsgpackCdbCreateCheckpoint): CdbCreateCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbCreateCheckpoint deserialization"); };
+  return {
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbCommitCheckpoint(o: MsgpackCdbCommitCheckpoint): CdbCommitCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbCommitCheckpoint deserialization"); };
+  return {
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbRevertCheckpoint(o: MsgpackCdbRevertCheckpoint): CdbRevertCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbRevertCheckpoint deserialization"); };
+  return {
+    forkId: assertU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function toCdbGetContractInstanceResponse(o: MsgpackCdbGetContractInstanceResponse): CdbGetContractInstanceResponse {
+;
+  return {
+    instance: o.instance ?? null,
+  };
+}
+
+export function toCdbGetContractClassResponse(o: MsgpackCdbGetContractClassResponse): CdbGetContractClassResponse {
+;
+  return {
+    contractClass: o.contractClass ?? null,
+  };
+}
+
+export function toCdbGetBytecodeCommitmentResponse(o: MsgpackCdbGetBytecodeCommitmentResponse): CdbGetBytecodeCommitmentResponse {
+;
+  return {
+    commitment: o.commitment != null ? assertBin32(o.commitment, "o.commitment") : null,
+  };
+}
+
+export function toCdbGetDebugFunctionNameResponse(o: MsgpackCdbGetDebugFunctionNameResponse): CdbGetDebugFunctionNameResponse {
+;
+  return {
+    name: o.name ?? null,
+  };
+}
+
+export function toCdbAddContractsResponse(o: MsgpackCdbAddContractsResponse): CdbAddContractsResponse {
+  return {};
+}
+
+export function toCdbCreateCheckpointResponse(o: MsgpackCdbCreateCheckpointResponse): CdbCreateCheckpointResponse {
+  return {};
+}
+
+export function toCdbCommitCheckpointResponse(o: MsgpackCdbCommitCheckpointResponse): CdbCommitCheckpointResponse {
+  return {};
+}
+
+export function toCdbRevertCheckpointResponse(o: MsgpackCdbRevertCheckpointResponse): CdbRevertCheckpointResponse {
+  return {};
+}
+
+export function toCdbErrorResponse(o: MsgpackCdbErrorResponse): CdbErrorResponse {
+  if (o.message === undefined) { throw new Error("Expected message in CdbErrorResponse deserialization"); };
+  return {
+    message: o.message,
+  };
+}
+
+export function fromCdbGetContractInstance(o: CdbGetContractInstance): MsgpackCdbGetContractInstance {
+  if (o.address === undefined) { throw new Error("Expected address in CdbGetContractInstance serialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetContractInstance serialization"); };
+  return {
+  address: assertBin32(o.address, "o.address"),
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbGetContractClass(o: CdbGetContractClass): MsgpackCdbGetContractClass {
+  if (o.classId === undefined) { throw new Error("Expected classId in CdbGetContractClass serialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetContractClass serialization"); };
+  return {
+  classId: assertBin32(o.classId, "o.classId"),
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbGetBytecodeCommitment(o: CdbGetBytecodeCommitment): MsgpackCdbGetBytecodeCommitment {
+  if (o.classId === undefined) { throw new Error("Expected classId in CdbGetBytecodeCommitment serialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetBytecodeCommitment serialization"); };
+  return {
+  classId: assertBin32(o.classId, "o.classId"),
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbGetDebugFunctionName(o: CdbGetDebugFunctionName): MsgpackCdbGetDebugFunctionName {
+  if (o.address === undefined) { throw new Error("Expected address in CdbGetDebugFunctionName serialization"); }
+  if (o.selector === undefined) { throw new Error("Expected selector in CdbGetDebugFunctionName serialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbGetDebugFunctionName serialization"); };
+  return {
+  address: assertBin32(o.address, "o.address"),
+  selector: assertBin32(o.selector, "o.selector"),
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbAddContracts(o: CdbAddContracts): MsgpackCdbAddContracts {
+  if (o.contractDeploymentData === undefined) { throw new Error("Expected contractDeploymentData in CdbAddContracts serialization"); }
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbAddContracts serialization"); };
+  return {
+  contractDeploymentData: o.contractDeploymentData,
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbCreateCheckpoint(o: CdbCreateCheckpoint): MsgpackCdbCreateCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbCreateCheckpoint serialization"); };
+  return {
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbCommitCheckpoint(o: CdbCommitCheckpoint): MsgpackCdbCommitCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbCommitCheckpoint serialization"); };
+  return {
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbRevertCheckpoint(o: CdbRevertCheckpoint): MsgpackCdbRevertCheckpoint {
+  if (o.forkId === undefined) { throw new Error("Expected forkId in CdbRevertCheckpoint serialization"); };
+  return {
+  forkId: toWireU64(o.forkId, "o.forkId"),
+  };
+}
+
+export function fromCdbGetContractInstanceResponse(o: CdbGetContractInstanceResponse): MsgpackCdbGetContractInstanceResponse {
+;
+  return {
+  instance: o.instance ?? null,
+  };
+}
+
+export function fromCdbGetContractClassResponse(o: CdbGetContractClassResponse): MsgpackCdbGetContractClassResponse {
+;
+  return {
+  contractClass: o.contractClass ?? null,
+  };
+}
+
+export function fromCdbGetBytecodeCommitmentResponse(o: CdbGetBytecodeCommitmentResponse): MsgpackCdbGetBytecodeCommitmentResponse {
+;
+  return {
+  commitment: o.commitment != null ? assertBin32(o.commitment, "o.commitment") : null,
+  };
+}
+
+export function fromCdbGetDebugFunctionNameResponse(o: CdbGetDebugFunctionNameResponse): MsgpackCdbGetDebugFunctionNameResponse {
+;
+  return {
+  name: o.name ?? null,
+  };
+}
+
+export function fromCdbAddContractsResponse(o: CdbAddContractsResponse): MsgpackCdbAddContractsResponse {
+  return {};
+}
+
+export function fromCdbCreateCheckpointResponse(o: CdbCreateCheckpointResponse): MsgpackCdbCreateCheckpointResponse {
+  return {};
+}
+
+export function fromCdbCommitCheckpointResponse(o: CdbCommitCheckpointResponse): MsgpackCdbCommitCheckpointResponse {
+  return {};
+}
+
+export function fromCdbRevertCheckpointResponse(o: CdbRevertCheckpointResponse): MsgpackCdbRevertCheckpointResponse {
+  return {};
+}
+
+export function fromCdbErrorResponse(o: CdbErrorResponse): MsgpackCdbErrorResponse {
+  if (o.message === undefined) { throw new Error("Expected message in CdbErrorResponse serialization"); };
+  return {
+  message: o.message,
+  };
+}
+
+// Base API interfaces
+export interface AsyncApiBase {
+  getContractInstance(command: CdbGetContractInstance): Promise<CdbGetContractInstanceResponse>;
+  getContractClass(command: CdbGetContractClass): Promise<CdbGetContractClassResponse>;
+  getBytecodeCommitment(command: CdbGetBytecodeCommitment): Promise<CdbGetBytecodeCommitmentResponse>;
+  getDebugFunctionName(command: CdbGetDebugFunctionName): Promise<CdbGetDebugFunctionNameResponse>;
+  addContracts(command: CdbAddContracts): Promise<CdbAddContractsResponse>;
+  createCheckpoint(command: CdbCreateCheckpoint): Promise<CdbCreateCheckpointResponse>;
+  commitCheckpoint(command: CdbCommitCheckpoint): Promise<CdbCommitCheckpointResponse>;
+  revertCheckpoint(command: CdbRevertCheckpoint): Promise<CdbRevertCheckpointResponse>;
+  destroy(): Promise<void>;
+}
+
+export interface SyncApiBase {
+  getContractInstance(command: CdbGetContractInstance): CdbGetContractInstanceResponse;
+  getContractClass(command: CdbGetContractClass): CdbGetContractClassResponse;
+  getBytecodeCommitment(command: CdbGetBytecodeCommitment): CdbGetBytecodeCommitmentResponse;
+  getDebugFunctionName(command: CdbGetDebugFunctionName): CdbGetDebugFunctionNameResponse;
+  addContracts(command: CdbAddContracts): CdbAddContractsResponse;
+  createCheckpoint(command: CdbCreateCheckpoint): CdbCreateCheckpointResponse;
+  commitCheckpoint(command: CdbCommitCheckpoint): CdbCommitCheckpointResponse;
+  revertCheckpoint(command: CdbRevertCheckpoint): CdbRevertCheckpointResponse;
+  destroy(): void;
+}