@effectstream/midnight-contracts 0.104.1 → 0.200.2

package/src/providers.ts

@@ -3,11 +3,15 @@
 // ============================================================================
 
 import { Buffer } from "node:buffer";
-import type { ZswapSecretKeys, DustSecretKey, CoinPublicKey, EncPublicKey, FinalizedTransaction, TransactionId } from "@midnight-ntwrk/ledger-v8";
+import * as path from "node:path";
+import type { ZswapSecretKeys, DustSecretKey, CoinPublicKey, EncPublicKey, FinalizedTransaction, TransactionId } from "@midnightntwrk/ledger-v9";
 import { httpClientProofProvider } from "@midnight-ntwrk/midnight-js-http-client-proof-provider";
 import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
 import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";
-import { NodeZkConfigProvider } from "@midnight-ntwrk/midnight-js-node-zk-config-provider";
+import {
+  NodeZkConfigProvider,
+  nodeZkConfigRegistry,
+} from "@midnight-ntwrk/midnight-js-node-zk-config-provider";
 import type { WalletProvider, MidnightProvider, MidnightProviders, UnboundTransaction } from "@midnight-ntwrk/midnight-js-types";
 import type { WalletFacade } from "@midnightntwrk/wallet-sdk-facade";
 import type { NetworkUrls } from "./types.ts";
@@ -27,7 +31,7 @@ function createTtl(): Date {
  * Create wallet and midnight provider adapter for WalletFacade
  *
  * Implements the WalletProvider and MidnightProvider interfaces
- * as defined in @midnight-ntwrk/midnight-js-types v3.x
+ * as defined in @midnight-ntwrk/midnight-js-types v5.
  */
 function createWalletAndMidnightProvider(
     wallet: WalletFacade,
@@ -51,13 +55,15 @@ function createWalletAndMidnightProvider(
         ttl?: Date
       ): Promise<FinalizedTransaction> {
         console.log("✅ Balancing transaction", tx);
-        const bound = tx.bind();
-        const finalizedTransactionRecipe = await wallet.balanceFinalizedTransaction(bound, {
+        const unboundTransactionRecipe = await wallet.balanceUnboundTransaction(tx, {
           shieldedSecretKeys: zswapSecretKeys, 
           dustSecretKey: dustSecretKey,
          }, { ttl: ttl ?? createTtl() } );
-        const x = await wallet.signRecipe(finalizedTransactionRecipe, (payload) => unshieldedKeystore.signData(payload));
-        return wallet.finalizeRecipe(x);
+        const signedRecipe = await wallet.signRecipe(
+          unboundTransactionRecipe,
+          (payload) => unshieldedKeystore.signDataAsync(payload),
+        );
+        return wallet.finalizeRecipe(signedRecipe);
       },
       submitTx(tx: FinalizedTransaction): Promise<TransactionId> {
         console.log("✅ Submitting transaction", tx);
@@ -69,7 +75,7 @@ function createWalletAndMidnightProvider(
   /**
    * Configure all providers needed for contract deployment
    */
-  export function configureMidnightNodeProviders(
+  export async function configureMidnightNodeProviders(
     wallet: WalletFacade,
     zswapSecretKeys: ZswapSecretKeys,
     walletZswapSecretKeys: ZswapSecretKeys,
@@ -79,7 +85,7 @@ function createWalletAndMidnightProvider(
     privateStateStoreName: string,
     zkConfigPath: string,
     unshieldedKeystore: UnshieldedKeystore
-  ): MidnightProviders {
+  ): Promise<MidnightProviders> {
     const signingKeyStoreName = `${privateStateStoreName}-signing-keys`;
     const walletAndMidnightProvider = createWalletAndMidnightProvider(
       wallet,
@@ -89,7 +95,13 @@ function createWalletAndMidnightProvider(
       walletDustSecretKey,
       unshieldedKeystore
     );
-    const zkConfigProvider = new NodeZkConfigProvider(zkConfigPath);
+    const zkConfigProvider = new NodeZkConfigProvider(zkConfigPath, {
+      verify: "require",
+    });
+    // Midnight.js 5 resolves proof artifacts through a registry so transactions
+    // with cross-contract calls can select bundles by verifier key. Search from
+    // the managed-artifact parent to include sibling compiled contracts.
+    const zkConfigRegistry = await nodeZkConfigRegistry(path.dirname(zkConfigPath));
     return {
       // For deployment, we use full private state config because we may need to verify
       // the deployed contract state. For batcher/transaction submission use cases,
@@ -109,8 +121,11 @@ function createWalletAndMidnightProvider(
         networkUrls.indexerWS
       ),
       zkConfigProvider,
-      proofProvider: httpClientProofProvider(networkUrls.proofServer, zkConfigProvider),
+      proofProvider: httpClientProofProvider(
+        networkUrls.proofServer,
+        zkConfigRegistry,
+      ),
       walletProvider: walletAndMidnightProvider,
       midnightProvider: walletAndMidnightProvider,
     };
-  }
+  }

package/src/types.ts

@@ -1,4 +1,5 @@
-import type { ZswapSecretKeys, DustSecretKey } from "@midnight-ntwrk/ledger-v8";
+import type { ZswapSecretKeys, DustSecretKey } from "@midnightntwrk/ledger-v9";
+import type { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
 import type { WalletFacade } from "@midnightntwrk/wallet-sdk-facade";
 import type { UnshieldedKeystore } from "@midnightntwrk/wallet-sdk-unshielded-wallet";
 
@@ -61,10 +62,10 @@ export interface DeployConfig {
  */
 export interface NetworkUrls {
   /** Optional network ID override */
-  id?: string;
-  /** GraphQL indexer HTTP endpoint (default: http://127.0.0.1:8088/api/v3/graphql)*/
+  id?: NetworkId.NetworkId;
+  /** GraphQL indexer HTTP endpoint (default: http://127.0.0.1:8088/api/v4/graphql)*/
   indexer?: string;
-  /** GraphQL indexer WebSocket endpoint (default: ws://127.0.0.1:8088/api/v3/graphql/ws)*/
+  /** GraphQL indexer WebSocket endpoint (default: ws://127.0.0.1:8088/api/v4/graphql/ws)*/
   indexerWS?: string;
   /** Midnight node RPC endpoint (default: http://127.0.0.1:9944)*/
   node?: string;
@@ -91,4 +92,4 @@ export interface WalletResult {
   dustAddress: string;
   unshieldedAddress: string;
   unshieldedKeystore: UnshieldedKeystore;
-}
+}

package/test/integration-rc-stack.ts

@@ -0,0 +1,223 @@
+import { pathToFileURL } from "node:url";
+
+import { nativeToken } from "@midnightntwrk/ledger-v9";
+import type { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
+import type { WalletFacade } from "@midnightntwrk/wallet-sdk-facade";
+import * as Rx from "rxjs";
+
+import { deployMidnightContract } from "../src/deploy.ts";
+import {
+  buildWalletFacade,
+  registerNightForDust,
+  resolveFacadeDustAvailableCoins,
+  syncAndWaitForFunds,
+} from "../src/get-wallet-info.ts";
+import type { NetworkUrls, WalletResult } from "../src/types.ts";
+
+const networkId = "undeployed" as NetworkId.NetworkId;
+const timeoutMs = Number(process.env.MIDNIGHT_WALLET_SYNC_TIMEOUT_MS ?? "600000");
+const fundingAmount = BigInt(process.env.M3_FUNDING_AMOUNT ?? "10000000000000");
+const sourceSeed = process.env.M3_SOURCE_SEED ??
+  "0000000000000000000000000000000000000000000000000000000000000001";
+const recipientSeed = process.env.M3_RECIPIENT_SEED ??
+  "00000000000000000000000000000000000000000000000000000000000000a3";
+const contractBaseDir = requiredEnv("M3_CONTRACT_BASE_DIR");
+const contractModule = requiredEnv("M3_CONTRACT_MODULE");
+
+const networkUrls: Required<NetworkUrls> = {
+  id: networkId,
+  indexer: requiredEnv("MIDNIGHT_INDEXER_HTTP"),
+  indexerWS: requiredEnv("MIDNIGHT_INDEXER_WS"),
+  node: requiredEnv("MIDNIGHT_NODE_HTTP"),
+  proofServer: requiredEnv("MIDNIGHT_PROOF_SERVER_URL"),
+};
+
+const wallets: WalletResult[] = [];
+let recipientWasPassedToDeploy = false;
+
+try {
+  checkpoint("integration-start", {
+    runtime: `bun-${Bun.version}`,
+    networkId,
+    endpoints: networkUrls,
+    fundingAmount: fundingAmount.toString(),
+  });
+
+  const source = await buildWalletFacade(networkUrls, sourceSeed, networkId);
+  wallets.push(source);
+  await syncAndWaitForFunds(source.wallet, { timeoutMs });
+  const sourceState = await waitForFacadeState(
+    source.wallet,
+    "source wallet with NIGHT and spendable DUST",
+    (state) =>
+      allStrictlyComplete(state) &&
+      unshieldedNight(state) >= fundingAmount &&
+      resolveFacadeDustAvailableCoins(state) >= 1,
+  );
+  checkpoint("source-wallet-ready", stateEvidence(sourceState));
+
+  const recipient = await buildWalletFacade(networkUrls, recipientSeed, networkId);
+  wallets.push(recipient);
+  await syncAndWaitForFunds(recipient.wallet, { timeoutMs });
+  const recipientBefore = await waitForFacadeState(
+    recipient.wallet,
+    "fresh recipient wallet fully synchronized",
+    allStrictlyComplete,
+  );
+  if (unshieldedNight(recipientBefore) !== 0n) {
+    throw new Error("recipient seed is not fresh: expected zero NIGHT before funding");
+  }
+  if (resolveFacadeDustAvailableCoins(recipientBefore) !== 0) {
+    throw new Error("recipient seed is not fresh: expected zero spendable DUST before registration");
+  }
+  checkpoint("recipient-wallet-strictly-complete", stateEvidence(recipientBefore));
+
+  const receiverAddress = await recipient.wallet.unshielded.getAddress();
+  const fundingRecipe = await source.wallet.transferTransaction(
+    [{
+      type: "unshielded",
+      outputs: [{
+        type: nativeToken().raw,
+        receiverAddress,
+        amount: fundingAmount,
+      }],
+    }],
+    {
+      shieldedSecretKeys: source.zswapSecretKeys,
+      dustSecretKey: source.dustSecretKey,
+    },
+    { ttl: new Date(Date.now() + 30 * 60 * 1_000) },
+  );
+  if (fundingRecipe.type !== "UNPROVEN_TRANSACTION") {
+    throw new Error(`unexpected funding recipe type: ${fundingRecipe.type}`);
+  }
+  const signedFundingRecipe = await source.wallet.signRecipe(
+    fundingRecipe,
+    (payload) => source.unshieldedKeystore.signDataAsync(payload),
+  );
+  const fundingTx = await source.wallet.finalizeRecipe(signedFundingRecipe);
+  const fundingTxId = await source.wallet.submitTransaction(fundingTx);
+  checkpoint("fresh-wallet-funded", { fundingTxId: String(fundingTxId) });
+
+  const fundedState = await waitForFacadeState(
+    recipient.wallet,
+    "fresh recipient NIGHT UTXO",
+    (state) =>
+      allStrictlyComplete(state) &&
+      unshieldedNight(state) >= fundingAmount &&
+      state.unshielded.availableCoins.some(
+        (coin: { meta: { registeredForDustGeneration: boolean } }) =>
+          coin.meta.registeredForDustGeneration === false,
+      ),
+  );
+  checkpoint("recipient-funded-and-unregistered", stateEvidence(fundedState));
+
+  if (!await registerNightForDust(recipient)) {
+    throw new Error("fresh recipient NIGHT-to-DUST registration failed");
+  }
+  const registeredState = await waitForFacadeState(
+    recipient.wallet,
+    "registered wallet with spendable DUST",
+    (state) =>
+      allStrictlyComplete(state) && resolveFacadeDustAvailableCoins(state) >= 1,
+  );
+  checkpoint("recipient-dust-registered", stateEvidence(registeredState));
+
+  const fixture = await import(pathToFileURL(contractModule).href) as {
+    Counter: { Contract: unknown };
+    witnesses: unknown;
+  };
+  recipientWasPassedToDeploy = true;
+  const contractAddress = await deployMidnightContract(
+    {
+      contractName: "contract-counter",
+      contractFileName: "contract-counter.json",
+      contractClass: fixture.Counter.Contract,
+      witnesses: fixture.witnesses,
+      privateStateId: "counterPrivateState",
+      initialPrivateState: { privateCounter: 0 },
+      privateStateStoreName: "m3-counter-private-state",
+      baseDir: contractBaseDir,
+    },
+    networkUrls,
+    undefined,
+    { walletResult: recipient },
+  );
+  if (!contractAddress) throw new Error("deployment returned an empty contract address");
+  checkpoint("dust-fee-deployment-finalized", {
+    contractAddress,
+    networkId,
+    dustCoinsBeforeDeployment: resolveFacadeDustAvailableCoins(registeredState),
+  });
+  checkpoint("integration-pass", { contractAddress, fundingTxId: String(fundingTxId) });
+} finally {
+  await Promise.allSettled(
+    wallets.map((entry, index) =>
+      index === 1 && recipientWasPassedToDeploy
+        ? Promise.resolve()
+        : entry.wallet.stop()
+    ),
+  );
+}
+
+function allStrictlyComplete(state: any): boolean {
+  return state.shielded.progress.isStrictlyComplete() &&
+    state.unshielded.progress.isStrictlyComplete() &&
+    state.dust.progress.isStrictlyComplete();
+}
+
+function unshieldedNight(state: any): bigint {
+  return state.unshielded.balances[nativeToken().raw] ?? 0n;
+}
+
+function stateEvidence(state: any): Record<string, unknown> {
+  return {
+    strictlyComplete: {
+      shielded: state.shielded.progress.isStrictlyComplete(),
+      unshielded: state.unshielded.progress.isStrictlyComplete(),
+      dust: state.dust.progress.isStrictlyComplete(),
+    },
+    unshieldedNight: unshieldedNight(state).toString(),
+    unregisteredNightCoins: state.unshielded.availableCoins.filter(
+      (coin: { meta: { registeredForDustGeneration: boolean } }) =>
+        coin.meta.registeredForDustGeneration === false,
+    ).length,
+    dustAvailableCoins: resolveFacadeDustAvailableCoins(state),
+  };
+}
+
+function waitForFacadeState(
+  wallet: WalletFacade,
+  description: string,
+  predicate: (state: any) => boolean,
+): Promise<any> {
+  let latest = "no state emitted";
+  return Rx.firstValueFrom(
+    wallet.state().pipe(
+      Rx.tap((state) => {
+        latest = JSON.stringify(stateEvidence(state));
+      }),
+      Rx.filter(predicate),
+      Rx.timeout({
+        first: timeoutMs,
+        with: () => Rx.throwError(
+          () => new Error(`timeout waiting for ${description}; latest=${latest}`),
+        ),
+      }),
+    ),
+  );
+}
+
+function checkpoint(name: string, details: Record<string, unknown> = {}): void {
+  console.log(JSON.stringify({
+    timestamp: new Date().toISOString(),
+    checkpoint: name,
+    ...details,
+  }));
+}
+
+function requiredEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`missing required environment variable ${name}`);
+  return value;
+}

package/test/migration.test.ts

@@ -0,0 +1,219 @@
+import { describe, expect, test } from "bun:test";
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import {
+  ZswapChainState,
+  addressFromKey,
+  sampleSigningKey,
+  signData,
+  signatureVerifyingKey,
+  verifySignature,
+  type SignatureKind,
+} from "@midnightntwrk/ledger-v9";
+import { WalletFacade } from "@midnightntwrk/wallet-sdk-facade";
+import * as Rx from "rxjs";
+
+import {
+  registerNightForDust,
+  resolveFacadeDustAvailableCoins,
+  resolveFacadeDustFundsReadiness,
+  waitForDustFunds,
+} from "../src/get-wallet-info.ts";
+import { defaultMidnightNetworkConfig } from "../src/midnight-env.ts";
+import type { WalletResult } from "../src/types.ts";
+
+describe("ledger-v9 compatibility traps", () => {
+  for (const kind of ["schnorr", "ecdsa"] satisfies SignatureKind[]) {
+    test(`${kind} signatures keep their tagged key and signature shapes`, () => {
+      const signingKey = sampleSigningKey(kind);
+      const verifyingKey = signatureVerifyingKey(signingKey);
+      const payload = new TextEncoder().encode(`effectstream-${kind}`);
+      const signature = signData(signingKey, payload);
+
+      expect(signingKey.tag).toBe(kind);
+      expect(verifyingKey.tag).toBe(kind);
+      expect(signature.tag).toBe(kind);
+      expect(signingKey.value).toMatch(/^[0-9a-f]+$/i);
+      expect(verifyingKey.value).toMatch(/^[0-9a-f]+$/i);
+      expect(signature.value).toMatch(/^[0-9a-f]+$/i);
+      expect(verifySignature(verifyingKey, payload, signature)).toBe(true);
+      expect(addressFromKey(verifyingKey)).toBeTruthy();
+    });
+  }
+
+  test("postBlockUpdate accepts the required retentionDuration", () => {
+    const updated = new ZswapChainState().postBlockUpdate(
+      new Date("2026-08-23T00:00:00.000Z"),
+      3_600n,
+    );
+    expect(updated).toBeInstanceOf(ZswapChainState);
+  });
+});
+
+describe("wallet-v2 migration", () => {
+  test("wallet node client and Polkadot share one BN constructor", () => {
+    const nodeClientRoot = realpathSync(
+      `${import.meta.dir}/../node_modules/@midnightntwrk/wallet-sdk-node-client`,
+    );
+    const nodeClientRequire = createRequire(`${nodeClientRoot}/package.json`);
+    const polkadotUtilRequire = createRequire(
+      nodeClientRequire.resolve("@polkadot/util/package.json"),
+    );
+    const NodeClientBN = nodeClientRequire("bn.js");
+    const PolkadotBN = polkadotUtilRequire("bn.js");
+    const blockNumber = new PolkadotBN(7);
+
+    expect(nodeClientRequire("bn.js/package.json").version).toBe("5.2.3");
+    expect(polkadotUtilRequire("bn.js/package.json").version).toBe("5.2.3");
+    expect(PolkadotBN).toBe(NodeClientBN);
+    expect(blockNumber).toBeInstanceOf(NodeClientBN);
+    expect(blockNumber.toString()).toBe("7");
+  });
+
+  test("WalletFacade exposes the async init entry point", () => {
+    expect(typeof WalletFacade.init).toBe("function");
+  });
+
+  test("DUST readiness counts spendable coins, not accrued balance", () => {
+    expect(
+      resolveFacadeDustAvailableCoins({
+        dust: { availableCoins: [], balance: () => 99n },
+      }),
+    ).toBe(0);
+    expect(
+      resolveFacadeDustAvailableCoins({
+        dust: { availableCoins: [{}], balance: () => 0n },
+      }),
+    ).toBe(1);
+  });
+
+  test("DUST readiness carries available coins when aggregate balance is zero", async () => {
+    const complete = { isStrictlyComplete: () => true };
+    const dustState = {
+      progress: complete,
+      availableCoins: [{ generatedNow: 10n }],
+      balance: () => 0n,
+    };
+    const wallet = { dust: { state: Rx.of(dustState) } } as unknown as WalletFacade;
+
+    const funds = await waitForDustFunds(wallet, {
+      timeoutMs: 100,
+      waitNonZero: true,
+      skipCatchUp: true,
+      dustPollIntervalMs: 0,
+    });
+
+    expect(funds).toEqual({
+      balance: 0n,
+      availableCoins: 1,
+      spendableCoins: 1,
+      ready: true,
+    });
+    expect(resolveFacadeDustFundsReadiness(dustState, 11n).ready).toBe(false);
+    expect(resolveFacadeDustFundsReadiness(dustState, 10n).ready).toBe(true);
+  });
+
+  test("registration finalizes the returned UnprovenTransactionRecipe", async () => {
+    const calls: string[] = [];
+    const signingKey = sampleSigningKey("schnorr");
+    const verifyingKey = signatureVerifyingKey(signingKey);
+    const recipe = {
+      type: "UNPROVEN_TRANSACTION" as const,
+      transaction: {},
+    };
+    const complete = { isStrictlyComplete: () => true };
+    const dustState = {
+      progress: complete,
+      availableCoins: [{}],
+      balance: () => 1n,
+    };
+    const facadeState = {
+      dust: dustState,
+      unshielded: {
+        progress: complete,
+        availableCoins: [
+          { meta: { registeredForDustGeneration: false } },
+        ],
+      },
+    };
+    const wallet = {
+      state: () => Rx.of(facadeState),
+      dust: { state: Rx.of(dustState) },
+      estimateRegistration: async () => {
+        calls.push("estimate");
+        return { fee: 5n, dustGenerationEstimations: [] };
+      },
+      waitForGeneratedDust: async (
+        _coins: readonly unknown[],
+        requiredAmount: bigint,
+      ) => {
+        calls.push("wait-generated");
+        expect(requiredAmount).toBe(5n);
+      },
+      registerNightUtxosForDustGeneration: async (
+        _coins: readonly unknown[],
+        key: unknown,
+        sign: (payload: Uint8Array) => Promise<unknown>,
+      ) => {
+        calls.push("register");
+        expect(key).toEqual(verifyingKey);
+        await sign(new Uint8Array([1, 2, 3]));
+        return recipe;
+      },
+      finalizeRecipe: async (received: unknown) => {
+        calls.push("finalize");
+        expect(received).toBe(recipe);
+        return { finalized: true };
+      },
+      submitTransaction: async () => {
+        calls.push("submit");
+        return "tx-id";
+      },
+    };
+    const walletResult = {
+      wallet,
+      unshieldedKeystore: {
+        getPublicKey: () => verifyingKey,
+        signDataAsync: async (payload: Uint8Array) =>
+          signData(signingKey, payload),
+      },
+    } as unknown as WalletResult;
+
+    expect(await registerNightForDust(walletResult)).toBe(true);
+    expect(calls).toEqual([
+      "estimate",
+      "wait-generated",
+      "register",
+      "finalize",
+      "submit",
+    ]);
+  });
+});
+
+describe("network defaults", () => {
+  test("undeployed uses local GraphQL v4 endpoints", () => {
+    const config = defaultMidnightNetworkConfig("undeployed");
+    expect(config.indexer).toBe("http://127.0.0.1:8088/api/v4/graphql");
+    expect(config.indexerWS).toBe("ws://127.0.0.1:8088/api/v4/graphql/ws");
+  });
+
+  for (const networkId of [
+    "mainnet",
+    "testnet",
+    "devnet",
+    "qanet",
+    "preview",
+    "preprod",
+    "stagenet",
+    "future-network",
+  ]) {
+    test(`preserves deployed network ID ${networkId}`, () => {
+      const config = defaultMidnightNetworkConfig(networkId);
+      expect(config.networkId).toBe(networkId);
+      expect(config.indexer).toBe(
+        `https://indexer.${networkId}.midnight.network/api/v4/graphql`,
+      );
+      expect(config.node).toBe(`https://rpc.${networkId}.midnight.network`);
+    });
+  }
+});

package/test/migration.typecheck.ts

@@ -0,0 +1,27 @@
+import {
+  ZswapChainState,
+  type Signature,
+  type SignatureVerifyingKey,
+  type SigningKey,
+} from "@midnightntwrk/ledger-v9";
+
+const signingKey: SigningKey = { tag: "schnorr", value: "00" };
+const verifyingKey: SignatureVerifyingKey = { tag: "ecdsa", value: "00" };
+const signature: Signature = { tag: "schnorr", value: "00" };
+void [signingKey, verifyingKey, signature];
+
+// The legacy string representation must stay rejected by ledger-v9 types.
+// @ts-expect-error ledger-v9 signing keys are tagged values
+const legacySigningKey: SigningKey = "00";
+// @ts-expect-error ledger-v9 verifying keys are tagged values
+const legacyVerifyingKey: SignatureVerifyingKey = "00";
+// @ts-expect-error ledger-v9 signatures are tagged values
+const legacySignature: Signature = "00";
+void [legacySigningKey, legacyVerifyingKey, legacySignature];
+
+if (false) {
+  const state = new ZswapChainState();
+  state.postBlockUpdate(new Date(), 60n);
+  // @ts-expect-error ledger-v9 requires retentionDuration
+  state.postBlockUpdate(new Date());
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}