Managing private state in Midnight DApps

// This would be a compile error — commitment() returns a value derived from witnesses (private)
scoreCommitment = commitment(sk, score);

// This is correct — disclose() explicitly marks the intent to publish
scoreCommitment = disclose(commitment(sk, score));

export type ScorePrivateState = {
  readonly secretKey: Uint8Array; // Compact: Bytes<32>
  readonly score: bigint;         // Compact: Uint<64>
};

export const createScorePrivateState = (
  secretKey: Uint8Array,
  score: bigint = 0n
): ScorePrivateState => ({ secretKey, score });

// Browser environment
const secretKey = crypto.getRandomValues(new Uint8Array(32));
const privateState = createScorePrivateState(secretKey);

// Node.js environment
import { randomBytes } from "node:crypto";

const secretKey = randomBytes(32);
const privateState = createScorePrivateState(secretKey);

const state = { secretKey: new Uint8Array([1, 2, 3]) };
const roundTripped = JSON.parse(JSON.stringify(state));

// roundTripped.secretKey is { '0': 1, '1': 2, '2': 3 } — an object, not a Uint8Array

// Safe serialization for Uint8Array
function serializeKey(key: Uint8Array): number[] {
  return Array.from(key);
}

function deserializeKey(raw: number[]): Uint8Array {
  return new Uint8Array(raw);
}

JSON.stringify({ balance: 1000n });
// TypeError: Do not know how to serialize a BigInt

// Safe serialization for bigint
function serializeBalance(balance: bigint): string {
  return balance.toString();
}

function deserializeBalance(raw: string): bigint {
  return BigInt(raw);
}

witness localSecretKey(): Bytes<32>;

pragma language_version >= 0.16 && <= 0.22;
import CompactStandardLibrary;

// -- Public ledger state --------------------------------------------------
// One field: a hash committing to (secretKey, score).
// Neither value is revealed on-chain.

export ledger scoreCommitment: Bytes<32>;

// -- Witness declarations --------------------------------------------------
// No bodies here — implementations are in src/witnesses.ts.

witness localSecretKey(): Bytes<32>;
witness localScore(): Uint<64>;

// -- Helper circuit -------------------------------------------------------
// Derives a commitment from (secretKey, score).
// The domain separator "score-tracker:v1:" scopes this hash to this contract.

circuit commitment(sk: Bytes<32>, score: Uint<64>): Bytes<32> {
  const scoreBytes = (score as Field) as Bytes<32>;
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "score-tracker:v1:"),
    persistentHash<Vector<2, Bytes<32>>>([sk, scoreBytes])
  ]);
}

// -- Constructor ----------------------------------------------------------
// Runs once at deployment. Calls both witnesses and writes the initial commitment.

constructor() {
  const sk = localSecretKey();
  const score = localScore();
  scoreCommitment = disclose(commitment(sk, score));
}

// -- Circuits -------------------------------------------------------------

export circuit increment(): [] {
  const sk = localSecretKey();
  const score = localScore();

  // Prove we own the current commitment before we can change it
  assert(
    scoreCommitment == commitment(sk, score),
    "State mismatch: local score does not match on-chain commitment"
  );
  assert(score < (18446744073709551615 as Uint<64>), "Score has reached maximum value");

  scoreCommitment = disclose(commitment(sk, (score + (1 as Uint<64>)) as Uint<64>));
}

export circuit decrement(): [] {
  const sk = localSecretKey();
  const score = localScore();

  assert(
    scoreCommitment == commitment(sk, score),
    "State mismatch: local score does not match on-chain commitment"
  );
  assert(score > (0 as Uint<64>), "Score cannot go below zero");

  scoreCommitment = disclose(commitment(sk, (score - (1 as Uint<64>)) as Uint<64>));
}

import type { WitnessContext } from "@midnight-ntwrk/compact-runtime";
import type { Ledger } from "../contracts/managed/score/contract/index.js";

import type { WitnessContext } from "@midnight-ntwrk/compact-runtime";
import type { Ledger } from "../contracts/managed/score/contract/index.js";
import type { ScorePrivateState } from "./types.js";

type ScoreWitnessContext = WitnessContext<Ledger, ScorePrivateState>;

export const witnesses = {
  localSecretKey: ({
    privateState,
  }: ScoreWitnessContext): [ScorePrivateState, Uint8Array] => {
    if (privateState.secretKey.length !== 32) {
      throw new Error("Corrupted private state: secretKey must be 32 bytes.");
    }
    // Return the unchanged private state and the secret key for the circuit.
    return [privateState, privateState.secretKey];
  },

  localScore: ({
    privateState,
  }: ScoreWitnessContext): [ScorePrivateState, bigint] => {
    // Return the unchanged private state and the current score for the circuit.
    return [privateState, privateState.score];
  },
};

localSecretKey: ({ privateState }) => {
  if (privateState.secretKey.length !== 32) {
    // Proof generation never starts — the error surfaces to the caller cleanly.
  throw new Error("Corrupted private state: secretKey must be 32 bytes.");
  }
  return [privateState, privateState.secretKey];
},

// Inside a circuit — these call your TypeScript witness implementations
const sk: Bytes<32> = localSecretKey();
const score: Uint<64> = localScore();

// The compiler rejects this — scoreCommitment is a ledger field (public),
// and commitment() returns a value derived from witnesses (private)
scoreCommitment = commitment(sk, score);

// The compiler accepts this — disclose() makes the intent explicit
scoreCommitment = disclose(commitment(sk, score));

circuit commitment(sk: Bytes<32>, score: Uint<64>): Bytes<32> {
  const scoreBytes = (score as Field) as Bytes<32>;
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "score-tracker:v1:"),
    persistentHash<Vector<2, Bytes<32>>>([sk, scoreBytes])
  ]);
}

// CLI input handler
if (cmd === "++") {
  await increment(contract, providers);
}

const stateBefore = await providers.privateStateProvider.get(ScorePrivateStateId);
if (!stateBefore) throw new Error("No private state found. Run deploy first.");

await contract.callTx.increment();

const stateAfter: ScorePrivateState = { ...stateBefore, score: stateBefore.score + 1n };
await providers.privateStateProvider.set(ScorePrivateStateId, stateAfter);

export async function increment(
  contract: DeployedScoreContract,
  providers: ScoreProviders
): Promise<void> {
  const stateBefore = await providers.privateStateProvider.get(ScorePrivateStateId);
  if (!stateBefore) throw new Error("No private state found. Run deploy first.");

  // Circuit call: witness invocation and proof generation happen automatically.
  // This call may take 10-30 seconds while the proof server works.
  await contract.callTx.increment();

  // The circuit does not write back to local storage: update it manually.
  const stateAfter: ScorePrivateState = { ...stateBefore, score: stateBefore.score + 1n };
  await providers.privateStateProvider.set(ScorePrivateStateId, stateAfter);
  console.log(`Score: ${stateBefore.score} -> ${stateAfter.score}`);
}

import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";

const provider = levelPrivateStateProvider<typeof ScorePrivateStateId, ScorePrivateState>({
  privateStateStoreName: "score-tracker",
  accountId: walletAddress,
  privateStoragePasswordProvider: () =>
    process.env.SCORE_STORAGE_PASSWORD ?? "ScoreTracker-Dev1!",
});

import { inMemoryPrivateStateProvider } from "@midnight-ntwrk/testkit-js";

// Usage in tests
const providers: ScoreProviders = {
  // ...other providers
  privateStateProvider: inMemoryPrivateStateProvider<
    typeof ScorePrivateStateId,
    ScorePrivateState
  >(),
};

import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";

// Define a unique string ID for this smart contract's private state.
// Each smart contract instance gets its own isolated storage bucket.
export const ScorePrivateStateId = "score" as const;

import type { MidnightProviders } from "@midnight-ntwrk/midnight-js-types";
import type { ProvableCircuits } from "../contracts/managed/score/contract/index.js";

export type ScoreProviders = MidnightProviders<
  ProvableCircuits<unknown>,
  typeof ScorePrivateStateId,
  ScorePrivateState
>;

const providers: ScoreProviders = {
  // ...other providers (wallet, node, indexer)...

  privateStateProvider: levelPrivateStateProvider<typeof ScorePrivateStateId, ScorePrivateState>({
    // A unique storage name prevents collisions if your DApp manages multiple smart contracts
    privateStateStoreName: "score-tracker",
    accountId: walletAddress,
    privateStoragePasswordProvider: () =>
      process.env.SCORE_STORAGE_PASSWORD ?? "ScoreTracker-Dev1!",
  }),
};

import { randomBytes } from "node:crypto";
import { createScorePrivateState, ScorePrivateStateId } from "./types.js";

// Generate a fresh secret key for this user
const secretKey = randomBytes(32);
const initialPrivateState = createScorePrivateState(secretKey, 0n);

const deployedContract = await deployContract(providers, {
  compiledContract: scoreCompiledContract,
  privateStateId: ScorePrivateStateId,
  initialPrivateState,
});

console.log(
  "Contract deployed at:",
  deployedContract.deployTxData.public.contractAddress
);
// Do NOT log deployedContract or initialPrivateState — they contain the secret key

import { findDeployedContract } from "@midnight-ntwrk/midnight-js-contracts";
import { createScorePrivateState, ScorePrivateStateId } from "./types.js";

const contract = await findDeployedContract(providers, {
  contractAddress,              // The known on-chain address
  compiledContract: scoreCompiledContract,  // The compiled Compact smart contract
  privateStateId: ScorePrivateStateId,      // Storage key
  initialPrivateState: createScorePrivateState(
    secretKey, 0n // Fallback only — SDK prefers stored state
  ),
});

mkdir score-tracker
cd score-tracker
npm init -y

# Midnight SDK — core runtime and contracts
npm install @midnight-ntwrk/compact-runtime
npm install @midnight-ntwrk/compact-js
npm install @midnight-ntwrk/midnight-js-contracts
npm install @midnight-ntwrk/midnight-js-types

# Midnight SDK — private state storage
npm install @midnight-ntwrk/midnight-js-level-private-state-provider

# Midnight SDK — wallet
npm install @midnight-ntwrk/testkit-js
npm install @midnight-ntwrk/ledger-v8
npm install @midnight-ntwrk/wallet-sdk-facade
npm install @midnight-ntwrk/midnight-js-utils

# Midnight SDK — network providers
npm install @midnight-ntwrk/midnight-js-http-client-proof-provider
npm install @midnight-ntwrk/midnight-js-indexer-public-data-provider
npm install @midnight-ntwrk/midnight-js-node-zk-config-provider
npm install @midnight-ntwrk/midnight-js-network-id

# Runtime deps required by testkit-js (not declared as its own dependencies)
npm install axios@^1.15.0 pino pino-pretty testcontainers rxjs

# Development tools
npm install -D typescript @types/node tsx

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "dist"
  },
  "include": ["src"]
}

{
  "type": "module",
  "scripts": {
    "compile-contract": "compact compile contracts/score.compact contracts/managed/score",
    "start": "tsx src/index.ts"
  }
}

score-tracker/
├── contracts/
│   └── score.compact              # Compact smart contract (you write this)
├── src/
│   ├── types.ts                   # Private state type, factory, serializer
│   ├── witnesses.ts               # Witness implementations
│   ├── wallet.ts                  # ScoreWalletProvider (signing, transaction submission)
│   ├── api.ts                     # Init, increment, decrement
│   └── index.ts                   # CLI entry point
└── package.json

// src/types.ts

export type ScorePrivateState = {
  readonly secretKey: Uint8Array; // Compact: Bytes<32>
  readonly score: bigint; // Compact: Uint<64>
};

/**
 * Factory function — the single place where fresh private state is created.
 * Default score is 0. Always generate a new secretKey with secure randomness.
 */
export const createScorePrivateState = (
  secretKey: Uint8Array,
  score: bigint = 0n
): ScorePrivateState => ({ secretKey, score });

/**
 * Serializer — converts private state to a plain JSON-safe object.
 * Uint8Array → number[] and bigint → string to survive JSON round-trip.
 * Used for backup files and schema migration; NOT needed for levelPrivateStateProvider.
 */
export function serializeScorePrivateState(state: ScorePrivateState): object {
  return {
    secretKey: Array.from(state.secretKey),
    score: state.score.toString(),
  };
}

/**
 * Deserializer — restores private state from a serialized object.
 * Must be the exact inverse of serializeScorePrivateState.
 */
export function deserializeScorePrivateState(raw: unknown): ScorePrivateState {
  if (typeof raw !== "object" || raw === null) {
    throw new Error("Invalid serialized state: expected an object.");
  }
  const obj = raw as Record<string, unknown>;
  if (!Array.isArray(obj.secretKey) || obj.secretKey.length !== 32) {
    throw new Error(
      "Invalid serialized state: secretKey must be an array of 32 numbers."
    );
  }
  const bytes = obj.secretKey as unknown[];
  for (let i = 0; i < bytes.length; i++) {
    const b = bytes[i];
    if (typeof b !== "number" || !Number.isInteger(b) || b < 0 || b > 255) {
      throw new Error(
        `Invalid serialized state: secretKey[${i}] is not a byte value (0-255).`
      );
    }
  }
  if (typeof obj.score !== "string" || !/^\d+$/.test(obj.score)) {
    throw new Error(
      "Invalid serialized state: score must be a decimal integer string."
    );
  }
  let score: bigint;
  try {
    score = BigInt(obj.score);
  } catch {
    throw new Error(
      "Invalid serialized state: score could not be parsed as a bigint."
    );
  }
  return {
    secretKey: new Uint8Array(bytes as number[]),
    score,
  };
}

pragma language_version >= 0.16 && <= 0.22;
import CompactStandardLibrary;

// -------------------------------------------------------
// PUBLIC LEDGER STATE
// One field: a hash committing to (secretKey, score).
// Neither value is revealed on-chain.
// -------------------------------------------------------

export ledger scoreCommitment: Bytes<32>;

// -------------------------------------------------------
// WITNESS DECLARATIONS
// No bodies here — implementations are in src/witnesses.ts.
// localSecretKey returns Bytes<32> (maps from Uint8Array).
// localScore returns Uint<64> (maps from bigint).
// -------------------------------------------------------

witness localSecretKey(): Bytes<32>;
witness localScore(): Uint<64>;

// -------------------------------------------------------
// HELPER: derive commitment from (key, score)
// -------------------------------------------------------

circuit commitment(sk: Bytes<32>, score: Uint<64>): Bytes<32> {
  // Uint<64> cannot be passed to pad() — cast through Field then to Bytes<32>
  const scoreBytes = (score as Field) as Bytes<32>;
  return persistentHash<Vector<2, Bytes<32>>>([
    pad(32, "score-tracker:v1:"),
    persistentHash<Vector<2, Bytes<32>>>([sk, scoreBytes])
  ]);
}

// -------------------------------------------------------
// CONSTRUCTOR
// Runs once, atomically at deployment time.
// Using constructor() instead of an exported initialize() circuit
// prevents a race condition where another caller could invoke
// initialize() before the deployer, claiming the contract with
// their own key.
// -------------------------------------------------------

constructor() {
  const sk = localSecretKey();
  const score = localScore();
  // Reveal only the commitment — key and score stay private
  scoreCommitment = disclose(commitment(sk, score));
}

// -------------------------------------------------------
// INCREMENT
// Verifies current commitment, then commits to (key, score+1).
// -------------------------------------------------------

export circuit increment(): [] {
  const sk = localSecretKey();
  const score = localScore();

  // Prove we own the current commitment before we can change it
  assert(
    scoreCommitment == commitment(sk, score),
    "State mismatch: local score does not match on-chain commitment"
  );

  assert(
    score < (18446744073709551615 as Uint<64>),
    "Score has reached maximum value"
  );

  // Arithmetic result must be cast back to Uint<64> before passing to commitment()
  scoreCommitment = disclose(commitment(sk, (score + (1 as Uint<64>)) as Uint<64>));
}

// -------------------------------------------------------
// DECREMENT
// Verifies current commitment, then commits to (key, score-1).
// -------------------------------------------------------

export circuit decrement(): [] {
  const sk = localSecretKey();
  const score = localScore();

  assert(
    scoreCommitment == commitment(sk, score),
    "State mismatch: local score does not match on-chain commitment"
  );

  assert(score > (0 as Uint<64>), "Score cannot go below zero");

  // Arithmetic result must be cast back to Uint<64> before passing to commitment()
  scoreCommitment = disclose(commitment(sk, (score - (1 as Uint<64>)) as Uint<64>));
}

npm run compile-contract

// src/witnesses.ts

import type { WitnessContext } from "@midnight-ntwrk/compact-runtime";
import type { Ledger } from "../contracts/managed/score/contract/index.js";
import type { ScorePrivateState } from "./types.js";

type ScoreWitnessContext = WitnessContext<Ledger, ScorePrivateState>;

export const witnesses = {
  /**
   * Returns the secret key to the circuit.
   * TypeScript: Uint8Array → Compact: Bytes<32>
   * Private state is unchanged.
   */
  localSecretKey: ({
    privateState,
  }: ScoreWitnessContext): [ScorePrivateState, Uint8Array] => {
    if (privateState.secretKey.length !== 32) {
      throw new Error("Corrupted private state: secretKey must be 32 bytes.");
    }
    return [privateState, privateState.secretKey];
  },

  /**
   * Returns the current score to the circuit.
   * TypeScript: bigint → Compact: Uint<64>
   * Private state is unchanged.
   */
  localScore: ({
    privateState,
  }: ScoreWitnessContext): [ScorePrivateState, bigint] => {
    return [privateState, privateState.score];
  },
};

// src/wallet.ts

import {
  DustSecretKey,
  LedgerParameters,
  ZswapSecretKeys,
  type CoinPublicKey,
  type EncPublicKey,
  type FinalizedTransaction,
} from "@midnight-ntwrk/ledger-v8";
import {
  type MidnightProvider,
  type UnboundTransaction,
  type WalletProvider,
} from "@midnight-ntwrk/midnight-js-types";
import { ttlOneHour } from "@midnight-ntwrk/midnight-js-utils";
import {
  type DustWalletOptions,
  type EnvironmentConfiguration,
  FluentWalletBuilder,
} from "@midnight-ntwrk/testkit-js";
import { type WalletFacade } from "@midnight-ntwrk/wallet-sdk-facade";
import { firstValueFrom } from "rxjs";

// Re-export so api.ts and index.ts can import EnvironmentConfiguration from one place.
export type { EnvironmentConfiguration };

// Minimal type for the unshielded keystore returned by FluentWalletBuilder.
// The builder's return type is not fully exported, so we cast with `as unknown`.
type Keystore = {
  signData(payload: Uint8Array): string;
};

export class ScoreWalletProvider implements WalletProvider, MidnightProvider {
  private constructor(
    private readonly wallet: WalletFacade,
    private readonly zswapSecretKeys: ZswapSecretKeys,
    private readonly dustSecretKey: DustSecretKey,
    private readonly keystore: Keystore
  ) {}

  // ── WalletProvider ──────────────────────────────────────────────────────────

  getCoinPublicKey(): CoinPublicKey {
    return this.zswapSecretKeys.coinPublicKey;
  }

  getEncryptionPublicKey(): EncPublicKey {
    return this.zswapSecretKeys.encryptionPublicKey;
  }

  // Balances a raw transaction (adds dust inputs/outputs), signs it, and finalises it.
  async balanceTx(
    tx: UnboundTransaction,
    ttl: Date = ttlOneHour()
  ): Promise<FinalizedTransaction> {
    const recipe = await this.wallet.balanceUnboundTransaction(
      tx,
      {
        shieldedSecretKeys: this.zswapSecretKeys,
        dustSecretKey: this.dustSecretKey,
      },
      { ttl }
    );
    const signedRecipe = await this.wallet.signRecipe(recipe, (payload) =>
      this.keystore.signData(payload)
    );
    return this.wallet.finalizeRecipe(signedRecipe);
  }

  // ── MidnightProvider ────────────────────────────────────────────────────────

  submitTx(tx: FinalizedTransaction): Promise<string> {
    return this.wallet.submitTransaction(tx);
  }

  // ── Lifecycle ───────────────────────────────────────────────────────────────

  async stop(): Promise<void> {
    return this.wallet.stop();
  }

  // ── Factory ─────────────────────────────────────────────────────────────────

  /**
   * Builds the wallet from a seed string, starts syncing, and returns:
   *   provider — implements both WalletProvider and MidnightProvider
   *   address  — the coin public key string, ready to display or fund
   */
  static async build(
    config: EnvironmentConfiguration,
    seed: string
  ): Promise<{ provider: ScoreWalletProvider; address: string }> {
    // additionalFeeOverhead compensates for the local devnet's non-standard fee model.
    const dustOptions: DustWalletOptions = {
      ledgerParams: LedgerParameters.initialParameters(),
      additionalFeeOverhead:
        config.walletNetworkId === "undeployed"
          ? 500_000_000_000_000_000n
          : 1_000n,
      feeBlocksMargin: 5,
    };

    const buildResult = await FluentWalletBuilder.forEnvironment(config)
      .withDustOptions(dustOptions)
      .withSeed(seed)
      .buildWithoutStarting();

    // The builder's return type is opaque; cast to extract what we need.
    const { wallet, seeds, keystore } = buildResult as unknown as {
      wallet: WalletFacade;
      seeds: { masterSeed: string; shielded: Uint8Array; dust: Uint8Array };
      keystore: Keystore;
    };

    const zswapSecretKeys = ZswapSecretKeys.fromSeed(seeds.shielded);
    const dustSecretKey = DustSecretKey.fromSeed(seeds.dust);

    // Read the wallet address before starting — avoids a race with the sync loop.
    const shieldedState = await firstValueFrom(wallet.shielded.state);
    const address = shieldedState.address.coinPublicKeyString();

    await wallet.start(zswapSecretKeys, dustSecretKey);

    return {
      provider: new ScoreWalletProvider(
        wallet,
        zswapSecretKeys,
        dustSecretKey,
        keystore
      ),
      address,
    };
  }
}

// src/api.ts

import { randomBytes } from "node:crypto";
import { fileURLToPath } from "node:url";
import { join, dirname } from "node:path";
import { CompiledContract } from "@midnight-ntwrk/compact-js";
import {
  deployContract,
  findDeployedContract,
  type FoundContract,
} from "@midnight-ntwrk/midnight-js-contracts";
import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";
import { NodeZkConfigProvider } from "@midnight-ntwrk/midnight-js-node-zk-config-provider";
import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
import { httpClientProofProvider } from "@midnight-ntwrk/midnight-js-http-client-proof-provider";
import { setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
import {
  type ScoreWalletProvider,
  type EnvironmentConfiguration,
} from "./wallet.js";
import * as Score from "../contracts/managed/score/contract/index.js";
import type { ProvableCircuits } from "../contracts/managed/score/contract/index.js";
import {
  type ScorePrivateState,
  createScorePrivateState,
  serializeScorePrivateState,
} from "./types.js";
import { witnesses } from "./witnesses.js";

// -------------------------------------------------------
// CONFIG
// setNetworkId must be called before any SDK interaction — each config
// class calls it in its constructor so the caller doesn't have to remember.
// The proof server always runs locally; ZK proof generation is private.
//
// Both classes implement EnvironmentConfiguration from @midnight-ntwrk/testkit-js,
// which is the interface expected by FluentWalletBuilder in wallet.ts.
// -------------------------------------------------------

// Local devnet — all services run on localhost via docker compose
// Start with: docker compose up -d (compose file is in the project root)
export class LocalConfig implements EnvironmentConfiguration {
  readonly walletNetworkId = "undeployed" as const;
  readonly networkId = "undeployed";
  readonly node = "http://localhost:9944";
  readonly nodeWS = "ws://localhost:9944";
  readonly indexer = "http://localhost:8088/api/v4/graphql";
  readonly indexerWS = "ws://localhost:8088/api/v4/graphql/ws";
  readonly proofServer = "http://localhost:6300";
  readonly faucet = undefined;

  constructor() {
    setNetworkId("undeployed");
  }
}

// Preprod testnet — public hosted endpoints, proof server still runs locally
export class PreprodConfig implements EnvironmentConfiguration {
  readonly walletNetworkId = "preprod" as const;
  readonly networkId = "preprod";
  readonly node = "https://rpc.preprod.midnight.network";
  readonly nodeWS = "wss://rpc.preprod.midnight.network";
  readonly indexer = "https://indexer.preprod.midnight.network/api/v4/graphql";
  readonly indexerWS =
    "wss://indexer.preprod.midnight.network/api/v4/graphql/ws";
  readonly proofServer = "http://localhost:6300";
  readonly faucet = undefined;

  constructor() {
    setNetworkId("preprod");
  }
}

// -------------------------------------------------------
// PRIVATE STATE ID
// Used as the storage key in levelPrivateStateProvider.
// -------------------------------------------------------

export const ScorePrivateStateId = "score" as const;

// -------------------------------------------------------
// COMPILED CONTRACT
// CompiledContract.make() combines the generated contract class with
// witness implementations and the path to the compiled ZK circuit keys on disk.
// Score.Contract is the class generated by `npm run compile-contract`.
// -------------------------------------------------------

const ZK_CONFIG_PATH = join(
  dirname(fileURLToPath(import.meta.url)),
  "../contracts/managed/score"
);

const scoreCompiledContract = CompiledContract.make(
  "score",
  Score.Contract
).pipe(
  CompiledContract.withWitnesses(witnesses),
  CompiledContract.withCompiledFileAssets(ZK_CONFIG_PATH)
);

// -------------------------------------------------------
// PROVIDERS
// Wires together all six midnight-js providers:
//   privateStateProvider — LevelDB storage for ScorePrivateState (local)
//   publicDataProvider   — reads on-chain ledger state via the indexer
//   zkConfigProvider     — loads compiled ZK circuit keys from disk
//   proofProvider        — sends private witness data to the local proof server
//   walletProvider       — signs transactions (provided by ScoreWalletProvider)
//   midnightProvider     — submits transactions to the Midnight node (same instance)
//
// ScoreWalletProvider implements both WalletProvider and MidnightProvider,
// so the same object is passed to both slots.
// -------------------------------------------------------

export function configureProviders(
  walletProvider: ScoreWalletProvider,
  config: EnvironmentConfiguration,
  walletAddress: string
) {
  const zkConfigProvider = new NodeZkConfigProvider<
    keyof ProvableCircuits<unknown>
  >(ZK_CONFIG_PATH);
  return {
    privateStateProvider: levelPrivateStateProvider<
      typeof ScorePrivateStateId,
      ScorePrivateState
    >({
      privateStateStoreName: "score-tracker",
      accountId: walletAddress,
      privateStoragePasswordProvider: () =>
        process.env.SCORE_STORAGE_PASSWORD ?? "ScoreTracker-Dev1!",
    }),
    publicDataProvider: indexerPublicDataProvider(
      config.indexer,
      config.indexerWS
    ),
    zkConfigProvider,
    proofProvider: httpClientProofProvider(
      config.proofServer,
      zkConfigProvider
    ),
    walletProvider,
    midnightProvider: walletProvider,
  };
}

export type ScoreProviders = Awaited<ReturnType<typeof configureProviders>>;

// -------------------------------------------------------
// DEPLOY
// Deploys the smart contract to the network.
// The constructor() circuit runs atomically at deployment — it calls both witnesses
// and writes the initial commitment on-chain.
// -------------------------------------------------------

export async function deployTracker(providers: ScoreProviders) {
  const secretKey = randomBytes(32);
  const initialPrivateState = createScorePrivateState(secretKey, 0n);

  const deployed = await deployContract(providers, {
    compiledContract: scoreCompiledContract,
    privateStateId: ScorePrivateStateId,
    initialPrivateState,
  });

  console.log(
    `Contract deployed at: ${deployed.deployTxData.public.contractAddress}`
  );
  // Never log deployed or initialPrivateState — they contain the secret key
  return deployed;
}

export type DeployedScoreContract = FoundContract<Score.Contract>;

// -------------------------------------------------------
// JOIN
// Reconnects to an existing smart contract at a known address.
// If no private state is stored locally for this address, `initialPrivateState`
// is used as the starting point — so pass the correct secretKey.
// -------------------------------------------------------

export async function joinTracker(
  providers: ScoreProviders,
  contractAddress: string,
  secretKey: Uint8Array
): Promise<DeployedScoreContract> {
  return findDeployedContract(providers, {
    contractAddress,
    compiledContract: scoreCompiledContract,
    privateStateId: ScorePrivateStateId,
    initialPrivateState: createScorePrivateState(secretKey, 0n),
  });
}

// -------------------------------------------------------
// INCREMENT
// Calls the circuit, then updates local private state to match.
// -------------------------------------------------------

export async function increment(
  contract: DeployedScoreContract,
  providers: ScoreProviders
): Promise<void> {
  const stateBefore = await providers.privateStateProvider.get(
    ScorePrivateStateId
  );
  if (!stateBefore)
    throw new Error("No private state found. Run deploy first.");

  // The circuit reads the current score through the localScore witness,
  // verifies it matches the on-chain commitment, then updates the commitment.
  await contract.callTx.increment();

  // The circuit does not write back to local storage — update it manually.
  const stateAfter: ScorePrivateState = {
    ...stateBefore,
    score: stateBefore.score + 1n,
  };
  await providers.privateStateProvider.set(ScorePrivateStateId, stateAfter);
  console.log(`Score: ${stateBefore.score} → ${stateAfter.score}`);
}

// -------------------------------------------------------
// DECREMENT
// Same pattern as increment, but guards against going below zero.
// -------------------------------------------------------

export async function decrement(
  contract: DeployedScoreContract,
  providers: ScoreProviders
): Promise<void> {
  const stateBefore = await providers.privateStateProvider.get(
    ScorePrivateStateId
  );
  if (!stateBefore) throw new Error("No private state found.");
  if (stateBefore.score === 0n) throw new Error("Score is already zero.");

  await contract.callTx.decrement();

  const stateAfter: ScorePrivateState = {
    ...stateBefore,
    score: stateBefore.score - 1n,
  };
  await providers.privateStateProvider.set(ScorePrivateStateId, stateAfter);
  console.log(`Score: ${stateBefore.score} → ${stateAfter.score}`);
}

// -------------------------------------------------------
// EXPORT BACKUP
// Serializes private state to a JSON string the user can save.
// Writes to disk rather than stdout — never print the secret key to the terminal.
// -------------------------------------------------------

export async function exportBackup(providers: ScoreProviders): Promise<string> {
  const state = await providers.privateStateProvider.get(ScorePrivateStateId);
  if (!state) throw new Error("Nothing to export.");
  return JSON.stringify(serializeScorePrivateState(state), null, 2);
}

// src/index.ts

import * as readline from "node:readline";
import { writeFile } from "node:fs/promises";
import {
  type DeployedScoreContract,
  type ScoreProviders,
  LocalConfig,
  configureProviders,
  deployTracker,
  joinTracker,
  increment,
  decrement,
  exportBackup,
} from "./api.js";
import { ScoreWalletProvider } from "./wallet.js";

// Wallet SDK background sync tasks emit unhandled rejections when the
// network is unreachable or when the process exits during active sync.
// Only suppress rejections that originate from wallet SDK internals.
process.on("unhandledRejection", (reason) => {
  const msg = reason instanceof Error ? reason.message : String(reason);
  if (
    msg.includes("WebSocket") ||
    msg.includes("disconnected") ||
    msg.includes("Connection reset") ||
    msg.includes("ECONNREFUSED")
  ) {
    return;
  }
  console.error("Unhandled rejection:", reason);
});

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
const ask = (q: string) =>
  new Promise<string>((resolve) => rl.question(q, resolve));

async function main() {
  // ── Config ─────────────────────────────────────────────────────────────────
  // LocalConfig calls setNetworkId('undeployed') in its constructor.
  // Swap to new PreprodConfig() to target the Preprod testnet instead.
  const config = new LocalConfig();

  // ── Wallet setup ──────────────────────────────────────────────────────────
  // LOCAL_TEST_SEED is the number 1 padded to 32 bytes. It is a well-known
  // test value — anyone who sees it can derive the same wallet and drain its funds.
  // NEVER use it on preprod or mainnet. Always set WALLET_SEED to a secret
  // seed you generated yourself before targeting any public network.
  // On the local devnet this address is pre-funded by the genesis block.
  const LOCAL_TEST_SEED =
    "0000000000000000000000000000000000000000000000000000000000000001";
  const seed = process.env.WALLET_SEED ?? LOCAL_TEST_SEED;

  console.log("Connecting to local network...");
  const { provider: walletProvider, address } = await ScoreWalletProvider.build(
    config,
    seed
  );
  console.log(`Wallet address: ${address}`);
  const providers: ScoreProviders = configureProviders(
    walletProvider,
    config,
    address
  );

  let contract: DeployedScoreContract | null = null;

  try {
    console.log(
      "\nScore Tracker ready. Commands: deploy | join <address> | ++ | -- | backup | exit\n"
    );
    while (true) {
      const input = (await ask("> ")).trim();
      const [cmd, ...args] = input.split(" ");

      if (cmd === "deploy") {
        // Deploys the smart contract. The constructor() circuit runs on-chain,
        // calling both witnesses and writing the initial commitment.
        contract = await deployTracker(providers);
      } else if (cmd === "join") {
        // Reconnects to an existing contract at a known address.
        // Requires the original secret key — stored in your backup file.
        const address = args[0];
        if (!address) {
          console.log("Usage: join <contractAddress>");
          continue;
        }
        const secretKeyHex = await ask("Enter your secret key (hex): ");
        const secretKey = Buffer.from(secretKeyHex.trim(), "hex");
        if (secretKey.length !== 32) {
          console.log("Secret key must be 32 bytes (64 hex chars).");
          continue;
        }
        contract = await joinTracker(
          providers,
          address,
          new Uint8Array(secretKey)
        );
      } else if (cmd === "++") {
        if (!contract) {
          console.log("Deploy or join a contract first.");
          continue;
        }
        await increment(contract, providers);
      } else if (cmd === "--") {
        if (!contract) {
          console.log("Deploy or join a contract first.");
          continue;
        }
        await decrement(contract, providers);
      } else if (cmd === "backup") {
        const json = await exportBackup(providers);
        // Write to disk — never print to stdout, which would expose the secret key
        // in terminal history, log files, and screen-sharing sessions.
        const backupPath = `./score-backup-${Date.now()}.json`;
        await writeFile(backupPath, json, "utf8");
        console.log(`Backup written to: ${backupPath}`);
        console.log(
          "Keep this file safe. Do not share it or store it anywhere outside your device."
        );
      } else if (cmd === "exit") {
        break;
      }
    }
  } finally {
    rl.close();
    await walletProvider.stop().catch(() => {});
  }
}

main().catch(console.error);

services:
  proof-server:
    image: "midnightntwrk/proof-server:8.0.3"
    container_name: "proof-server"
    ports:
      - "6300:6300"

  indexer:
    image: "midnightntwrk/indexer-standalone:4.0.0"
    container_name: "indexer"
    ports:
      - "8088:8088"
    environment:
      RUST_LOG: "indexer=info,chain_indexer=info,indexer_api=info,wallet_indexer=info,indexer_common=info,fastrace_opentelemetry=info,info"
      APP__INFRA__SECRET: "303132333435363738393031323334353637383930313233343536373839303132"
      APP__INFRA__NODE__URL: "ws://node:9944"
    healthcheck:
      test: ["CMD-SHELL", "cat /var/run/indexer-standalone/running"]
      start_interval: "5s"
      interval: "5s"
      timeout: "2s"
      retries: 2
      start_period: 5s
    depends_on:
      node:
        condition: service_started

  node:
    image: "midnightntwrk/midnight-node:0.22.1"
    container_name: "node"
    ports:
      - "9944:9944"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9944/health"]
      interval: 2s
      timeout: 5s
      retries: 5
      start_period: 5s
    environment:
      CFG_PRESET: "dev"

docker compose up -d

npm run compile-contract

npm start

Connecting to local network...
Wallet address: <your-address>

Score Tracker ready. Commands: deploy | join <address> | ++ | -- | backup | exit

> deploy
Contract deployed at: 65832fb...b53d

> ++
Score: 0 -> 1

> ++
Score: 1 -> 2

> --
Score: 2 -> 1

> backup
Backup written to: ./score-backup-1777699189013.json
Keep this file safe. Do not share it or store it anywhere outside your device.

> exit

// Never do this
console.log("Private state:", privateState);
console.log("Secret key:", privateState.secretKey);

// If you must debug, log only metadata
console.log("Witness called. Key length:", privateState.secretKey.length);

// Correct
export type ScorePrivateState = {
  readonly secretKey: Uint8Array;
  readonly score: bigint;
};

// Risky — nothing stops a witness from mutating fields instead of returning new state
export type ScorePrivateState = {
  secretKey: Uint8Array;
  score: bigint;
};

// Correct (browser)
const secretKey = crypto.getRandomValues(new Uint8Array(32));

// Correct (Node.js)
import { randomBytes } from "node:crypto";
const secretKey = randomBytes(32);

// Never do this
const secretKey = new Uint8Array(32).map(() => Math.floor(Math.random() * 256));

// Scoped to this smart contract and this key type
persistentHash<Vector<2, Bytes<32>>>([pad(32, "score-tracker:v1:"), persistentHash<Vector<2, Bytes<32>>>([sk, scoreBytes])])

// No separator — the same key in two contracts produces the same commitment,
// allowing cross-contract correlation of user identity
persistentHash<Vector<2, Bytes<32>>>([sequence, sk])

docker compose up -d

npm run compile-contract