Bump deps to prerelease, add ecdsa tests

.github/actions/setup/action.yml

@@ -6,6 +6,10 @@ inputs:
     description: "Skip Compact compiler installation"
     required: false
     default: "false"
+  compact-prerelease:
+    description: "Pre-release Compact compiler to fetch from GitHub releases (bridge until the toolchain ships stable). Keep in sync with setup.ts COMPACTC_VERSION."
+    required: false
+    default: "0.33.0-rc.2"
 
 runs:
   using: "composite"
@@ -44,3 +48,27 @@ runs:
       uses: midnightntwrk/setup-compact-action@4130145456ad3f45934788dd4a65647eb283e658 # loose commit/not released
       with:
         compact-version: "0.31.0"
+
+    # The tests pin a pre-release compiler (secp256k1 / 0.18 runtime) that
+    # `compact update` does not serve, so fetch its release asset directly and
+    # drop it where `compact +<version>` looks. Remove once the toolchain ships
+    # a stable release (then just bump compact-version above).
+    - name: Install pre-release Compact toolchain
+      if: ${{ inputs.skip-compact != 'true' }}
+      shell: bash
+      env:
+        VER: ${{ inputs.compact-prerelease }}
+      run: |
+        set -euo pipefail
+        # Reuse the platform dir the CLI already created for the stable install
+        # (e.g. x86_64-unknown-linux-musl), so the pre-release lands where the
+        # `+<version>` selector resolves it; fall back to the host triple.
+        PLAT="$(basename "$(find "$HOME/.compact/versions" -mindepth 2 -maxdepth 2 -type d 2>/dev/null | head -1)" 2>/dev/null || true)"
+        [ -z "$PLAT" ] && PLAT="$(uname -m)-unknown-linux-musl"
+        DEST="$HOME/.compact/versions/$VER/$PLAT"
+        mkdir -p "$DEST"
+        curl -fsSL -o /tmp/compactc.zip \
+          "https://github.com/LFDT-Minokawa/compact/releases/download/compactc-v$VER/compactc_v${VER}_${PLAT}.zip"
+        unzip -oq /tmp/compactc.zip -d "$DEST"
+        chmod +x "$DEST"/*
+        compact compile +"$VER" --version

packages/simulator/package.json

@@ -41,21 +41,22 @@
     "clean": "git clean -fXd"
   },
   "devDependencies": {
-    "@midnight-ntwrk/midnight-js-contracts": "^4.1.0",
-    "@midnight-ntwrk/midnight-js-types": "^4.1.0",
+    "@midnight-ntwrk/midnight-js-contracts": "5.0.0-beta.6",
+    "@midnight-ntwrk/midnight-js-types": "5.0.0-beta.6",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
     "@tsconfig/node24": "^24.0.3",
     "@types/node": "26.1.2",
     "fast-check": "^4.5.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-runtime": "0.16.0",
-    "@midnight-ntwrk/ledger-v8": "8.1.0"
+    "@midnight-ntwrk/compact-runtime": "0.18.0-rc.1"
   },
   "peerDependencies": {
-    "@midnight-ntwrk/midnight-js-contracts": "^4.1.0",
-    "@midnight-ntwrk/midnight-js-types": "^4.1.0"
+    "@midnight-ntwrk/midnight-js-contracts": "^5.0.0-beta.6",
+    "@midnight-ntwrk/midnight-js-types": "^5.0.0-beta.6"
   },
   "peerDependenciesMeta": {
     "@midnight-ntwrk/midnight-js-contracts": {

packages/simulator/src/core/AbstractSimulator.ts

@@ -93,7 +93,7 @@ export abstract class AbstractSimulator<P, L>
    * @returns The current private state of type P
    */
   public getPrivateState(): P {
-    return this.circuitContext.currentPrivateState;
+    return this.circuitContext.callContext.currentPrivateState as P;
   }
 
   /**
@@ -102,7 +102,7 @@ export abstract class AbstractSimulator<P, L>
    * @returns The current state value containing the ledger data
    */
   public getContractState(): StateValue {
-    return this.circuitContext.currentQueryContext.state.state;
+    return this.circuitContext.callContext.currentQueryContext.state.state;
   }
 
   /**
@@ -130,12 +130,13 @@ export abstract class AbstractSimulator<P, L>
         const original = Reflect.get(target, prop, receiver);
         if (typeof original !== 'function') return original;
 
-        return (...args: unknown[]) => {
+        return async (...args: unknown[]) => {
           const fn = original as (
             ctx: CircuitContext<P>,
             ...args: unknown[]
-          ) => { result: unknown };
-          const result = fn(context(), ...args).result;
+          ) => { result: unknown } | Promise<{ result: unknown }>;
+          // 0.18 circuits are async; `await` also tolerates the older sync shape.
+          const { result } = await fn(context(), ...args);
 
           // Auto-reset single-use caller override
           this.callerOverride = null;
@@ -172,13 +173,16 @@ export abstract class AbstractSimulator<P, L>
         const original = Reflect.get(target, prop, receiver);
         if (typeof original !== 'function') return original;
 
-        return (...args: unknown[]) => {
+        return async (...args: unknown[]) => {
           const fn = original as (
             ctx: CircuitContext<P>,
             ...args: unknown[]
-          ) => { result: unknown; context: CircuitContext<P> };
+          ) =>
+            | { result: unknown; context: CircuitContext<P> }
+            | Promise<{ result: unknown; context: CircuitContext<P> }>;
 
-          const { result, context: newCtx } = fn(context(), ...args);
+          // 0.18 circuits are async; `await` also tolerates the older sync shape.
+          const { result, context: newCtx } = await fn(context(), ...args);
           updateContext(newCtx);
 
           // Auto-reset single-use caller override

packages/simulator/src/core/CircuitContextManager.ts

@@ -4,10 +4,9 @@ import {
   type ConstructorContext,
   type ContractAddress,
   type ContractState,
-  CostModel,
+  createCircuitContext,
   createConstructorContext,
   type EncodedZswapLocalState,
-  QueryContext,
 } from '@midnight-ntwrk/compact-runtime';
 
 /**
@@ -16,12 +15,36 @@ import {
  * Handles initialization and lifecycle management of the `CircuitContext`,
  * which includes private state, public (ledger) state, zswap local state, and transaction context.
  */
+/** Shape of a compiled contract's constructor result (sync or async in 0.18). */
+type InitialStateResult<P> = {
+  currentPrivateState: P;
+  currentContractState: ContractState;
+  currentZswapLocalState: EncodedZswapLocalState;
+};
+
 export class CircuitContextManager<P> {
-  public context: CircuitContext<P>;
+  // Assigned by the async `init()`; the manager is always constructed and then
+  // awaited (`init`) before any circuit call reads the context.
+  public context!: CircuitContext<P>;
+
+  private readonly contract: {
+    initialState: (
+      ctx: ConstructorContext<P>,
+      ...args: any[]
+    ) => InitialStateResult<P> | Promise<InitialStateResult<P>>;
+  };
+  private readonly privateState: P;
+  private readonly coinPK: CoinPublicKey;
+  private readonly contractAddress: ContractAddress;
+  private readonly contractArgs: any[];
 
   /**
    * Creates an instance of `CircuitContextManager`.
    *
+   * @remarks compact-runtime 0.18 made `initialState` (and every circuit) async,
+   * so the constructor only records inputs; the context is built by the async
+   * {@link init}, which callers must await before using the manager.
+   *
    * @param contract - A compiled Compact contract instance exposing `initialState()`
    * @param contract.initialState - Function that initializes contract state given a constructor context
    * @param privateState - The initial private state to inject into the contract
@@ -34,34 +57,44 @@ export class CircuitContextManager<P> {
       initialState: (
         ctx: ConstructorContext<P>,
         ...args: any[]
-      ) => {
-        currentPrivateState: P;
-        currentContractState: ContractState;
-        currentZswapLocalState: EncodedZswapLocalState;
-      };
+      ) => InitialStateResult<P> | Promise<InitialStateResult<P>>;
     },
     privateState: P,
     coinPK: CoinPublicKey,
     contractAddress: ContractAddress,
     ...contractArgs: any[]
   ) {
-    const initCtx = createConstructorContext(privateState, coinPK);
+    this.contract = contract;
+    this.privateState = privateState;
+    this.coinPK = coinPK;
+    this.contractAddress = contractAddress;
+    this.contractArgs = contractArgs;
+  }
+
+  /**
+   * Runs the contract constructor and builds the initial `CircuitContext`.
+   * Must be awaited once, after construction, before any circuit call.
+   */
+  async init(): Promise<void> {
+    const initCtx = createConstructorContext(this.privateState, this.coinPK);
 
     const {
       currentPrivateState,
       currentContractState,
       currentZswapLocalState,
-    } = contract.initialState(initCtx, ...contractArgs);
-
-    // Extract ChargedState from the compiler-generated ContractState
-    const chargedState = currentContractState.data;
+    } = await this.contract.initialState(initCtx, ...this.contractArgs);
 
-    this.context = {
-      currentPrivateState,
+    // compact-runtime 0.18 restructured `CircuitContext` into a call-tree
+    // (`callContext` + per-contract `queryContexts`/`gasCosts`). Build it via
+    // the runtime's `createCircuitContext` factory rather than a hand-rolled
+    // literal so every required field is populated correctly.
+    this.context = createCircuitContext<P>(
+      'circuit',
+      this.contractAddress,
       currentZswapLocalState,
-      currentQueryContext: new QueryContext(chargedState, contractAddress),
-      costModel: CostModel.initialCostModel(),
-    };
+      currentContractState.data,
+      currentPrivateState,
+    );
   }
 
   /**
@@ -88,6 +121,6 @@ export class CircuitContextManager<P> {
    * @param newPrivateState - The new private state to set in the current context
    */
   updatePrivateState(newPrivateState: P) {
-    this.context.currentPrivateState = newPrivateState;
+    this.context.callContext.currentPrivateState = newPrivateState;
   }
 }

packages/simulator/src/core/ContractSimulator.ts

@@ -1,5 +1,6 @@
 import {
   type CircuitContext,
+  copyCircuitContext,
   emptyZswapLocalState,
 } from '@midnight-ntwrk/compact-runtime';
 import { AbstractSimulator } from './AbstractSimulator.js';
@@ -43,15 +44,16 @@ export abstract class ContractSimulator<P, L> extends AbstractSimulator<P, L> {
     const activeCaller = this.callerOverride || this.persistentCallerOverride;
     const baseCtx = this.circuitContext;
 
-    return {
-      currentPrivateState: baseCtx.currentPrivateState,
-      currentQueryContext: baseCtx.currentQueryContext,
-      currentZswapLocalState: activeCaller
-        ? emptyZswapLocalState(activeCaller)
-        : baseCtx.currentZswapLocalState,
-      costModel: baseCtx.costModel,
-      gasLimit: baseCtx.gasLimit,
-    };
+    if (!activeCaller) {
+      return baseCtx;
+    }
+
+    // compact-runtime 0.18: the caller-scoped fields live on `callContext`.
+    // Copy (shallow-clones `callContext`) before overriding the Zswap local
+    // state so the base context is left untouched.
+    const ctx = copyCircuitContext(baseCtx) as CircuitContext<P>;
+    ctx.callContext.currentZswapLocalState = emptyZswapLocalState(activeCaller);
+    return ctx;
   }
 
   /**

packages/simulator/src/factory/createDrySimulator.ts

@@ -34,7 +34,9 @@ export function createDrySimulator<
 >(config: SimulatorConfig<P, L, W, TContract, TArgs>) {
   return class GeneratedSimulator extends ContractSimulator<P, L> {
     contract: TContract;
-    readonly contractAddress: string;
+    // Assigned by the async `init()` (0.18 made `initialState` async, so the
+    // address — read from the built context — is not known at construction).
+    contractAddress!: string;
     public _witnesses: W;
 
     /**
@@ -65,8 +67,18 @@ export function createDrySimulator<
         contractAddress,
         ...processedArgs,
       );
+    }
 
-      this.contractAddress = this.circuitContext.currentQueryContext.address;
+    /**
+     * Runs the contract constructor and finalizes state. Must be awaited once,
+     * after construction, before any circuit call. Split out from the
+     * constructor because compact-runtime 0.18 made `initialState` async.
+     */
+    async init(): Promise<this> {
+      await this.circuitContextManager.init();
+      this.contractAddress =
+        this.circuitContext.callContext.currentQueryContext.address;
+      return this;
     }
 
     public _pureCircuitProxy?: ContextlessCircuits<
@@ -144,7 +156,7 @@ export function createDrySimulator<
      */
     getPublicState(): L {
       return config.ledgerExtractor(
-        this.circuitContext.currentQueryContext.state.state,
+        this.circuitContext.callContext.currentQueryContext.state.state,
       );
     }
 
@@ -191,8 +203,8 @@ export function createDrySimulator<
       const circuitCtx = this.circuitContext;
       return {
         ledger: this.getPublicState(),
-        privateState: circuitCtx.currentPrivateState,
-        contractAddress: circuitCtx.currentQueryContext.address,
+        privateState: circuitCtx.callContext.currentPrivateState as P,
+        contractAddress: circuitCtx.callContext.currentQueryContext.address,
       };
     }
   };

packages/simulator/src/factory/createSimulator.ts

@@ -85,6 +85,9 @@ export function createSimulator<
     // evaluator in live (D2). In live this runs `initialState` in memory only —
     // it is never deployed on-chain.
     const localSim = new DrySimClass(contractArgs, options);
+    // 0.18: `initialState` is async, so the constructor defers the constructor
+    // run to `init()`. Await it before deriving names / wiring any backend.
+    await localSim.init();
     const contract = localSim.contract;
     const impureNames = Object.keys(contract.impureCircuits);
     const impureSet = new Set(impureNames);
@@ -246,6 +249,15 @@ export function createSimulator<
       return this._signers;
     }
 
+    /**
+     * The deployed contract's address. Needed by callers that must reconstruct
+     * a circuit's message digest off-chain (e.g. signing an operation bound to
+     * `kernel.self()`).
+     */
+    get contractAddress(): string {
+      return this._backend.contractAddress;
+    }
+
     /**
      * Sets the caller for the next call only, then reverts.
      *

packages/simulator/src/signers/Signers.ts

@@ -1,6 +1,5 @@
 import {
   type CoinPublicKey,
-  convertFieldToBytes,
   encodeCoinPublicKey,
 } from '@midnight-ntwrk/compact-runtime';
 import type { BackendKind } from '../backend/Backend.js';
@@ -39,7 +38,10 @@ export type Either<L, R> = {
 const aliasToHex = (alias: string): CoinPublicKey =>
   Buffer.from(alias, 'ascii').toString('hex').padStart(64, '0');
 
-const zeroBytes = (): Uint8Array => convertFieldToBytes(32, 0n, '');
+// A 32-byte zero array. Previously derived via the runtime's
+// `convertFieldToBytes(32, 0n, '')`, which was removed in compact-runtime 0.18;
+// the value is identical (the byte encoding of field element 0).
+const zeroBytes = (): Uint8Array => new Uint8Array(32);
 
 /**
  * Configuration for {@link Signers}.