@effectstream/midnight-contracts 0.200.1 → 0.200.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/midnight-contracts",
-  "version": "0.200.1",
+  "version": "0.200.4",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -26,7 +26,7 @@
     "./types": "./src/types.ts"
   },
   "dependencies": {
-    "@effectstream/utils": "0.200.1",
+    "@effectstream/utils": "0.200.4",
     "@midnight-ntwrk/compact-js": "2.5.5-rc.7",
     "@midnight-ntwrk/compact-runtime": "0.18.0-rc.1",
     "@midnight-ntwrk/midnight-js-contracts": "5.0.0-beta.6",

package/src/midnight-env.ts

@@ -23,6 +23,7 @@ export type NetworkConfig = {
     indexerWS: string;
     node: string;
     proofServer: string;
+    faucetUrl?: string;
     networkId: NetworkId.NetworkId;
     genesisWalletSeed: string;
 }
@@ -47,17 +48,28 @@ const deployedNetworkConfig = (networkId: NetworkId.NetworkId): NetworkConfig =>
     genesisWalletSeed: '',
 });
 
+const stagenetNetworkConfig = Object.freeze({
+    indexer: "https://indexer.stagenet.shielded.tools/api/v4/graphql",
+    indexerWS: "wss://indexer.stagenet.shielded.tools/api/v4/graphql/ws",
+    node: "wss://rpc.stagenet.shielded.tools",
+    proofServer: "http://127.0.0.1:6300",
+    faucetUrl: "https://faucet.stagenet.shielded.tools/api/drips",
+    networkId: "stagenet" as NetworkId.NetworkId,
+    genesisWalletSeed: '',
+}) satisfies NetworkConfig;
+
 /**
- * Resolve defaults for every wallet-SDK network ID. Only `undeployed` uses
- * loopback services; every deployed or future network ID follows the hosted
- * Midnight endpoint convention instead of being restricted to `stagenet`.
+ * Resolve defaults for every wallet-SDK network ID. `undeployed` uses loopback
+ * services, Stagenet uses its explicit Shielded Tools profile, and every other
+ * deployed or future ID follows the hosted Midnight endpoint convention.
  */
 export const defaultMidnightNetworkConfig = (
   networkId: NetworkId.NetworkId,
-): NetworkConfig =>
-  networkId === "undeployed"
-    ? undeployedNetworkConfig
-    : deployedNetworkConfig(networkId);
+): NetworkConfig => {
+  if (networkId === "undeployed") return undeployedNetworkConfig;
+  if (networkId === "stagenet") return stagenetNetworkConfig;
+  return deployedNetworkConfig(networkId);
+};
 
 const networkId = (env("MIDNIGHT_NETWORK_ID") || "undeployed") as NetworkId.NetworkId;
 const selectedNetworkConfig = defaultMidnightNetworkConfig(networkId);
@@ -72,17 +84,25 @@ if (env("MIDNIGHT_WALLET_SEED")) {
   walletSeed = selectedNetworkConfig.genesisWalletSeed;
 }
 
-export const midnightNetworkConfig = {
+export type MidnightNetworkConfig = {
+  id: NetworkId.NetworkId;
+  indexer: string;
+  indexerWS: string;
+  node: string;
+  proofServer: string;
+  faucetUrl?: string;
+  walletSeed: string;
+};
+
+export const midnightNetworkConfig: MidnightNetworkConfig = {
   id: selectedNetworkConfig.networkId,
   indexer: env("MIDNIGHT_INDEXER_HTTP", selectedNetworkConfig.indexer),
   indexerWS: env("MIDNIGHT_INDEXER_WS", selectedNetworkConfig.indexerWS),
   node: env("MIDNIGHT_NODE_HTTP", selectedNetworkConfig.node),
   proofServer: env(["MIDNIGHT_PROOF_SERVER_URL", "MIDNIGHT_PROOF_SERVER"], selectedNetworkConfig.proofServer),
+  faucetUrl: selectedNetworkConfig.faucetUrl,
   walletSeed,
 };
 
 const isLocalProofServer = !!midnightNetworkConfig.proofServer.match(/(localhost|127\.0\.0\.1)/);
 export const isExternalProofServerConfigured = !isLocalProofServer;
-
-// Set this using MIDNIGHT_NETWORK_ID=<network-id>
-export type MidnightNetworkConfig = typeof midnightNetworkConfig;

package/test/migration.test.ts

@@ -19,7 +19,10 @@ import {
   resolveFacadeDustFundsReadiness,
   waitForDustFunds,
 } from "../src/get-wallet-info.ts";
-import { defaultMidnightNetworkConfig } from "../src/midnight-env.ts";
+import {
+  defaultMidnightNetworkConfig,
+  type MidnightNetworkConfig,
+} from "../src/midnight-env.ts";
 import type { WalletResult } from "../src/types.ts";
 
 describe("ledger-v9 compatibility traps", () => {
@@ -191,29 +194,172 @@ describe("wallet-v2 migration", () => {
 });
 
 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");
+  test("public config type accepts the complete pre-faucet object shape", () => {
+    const preFaucetConfig: MidnightNetworkConfig = {
+      id: "undeployed",
+      indexer: "http://127.0.0.1:8088/api/v4/graphql",
+      indexerWS: "ws://127.0.0.1:8088/api/v4/graphql/ws",
+      node: "http://127.0.0.1:9944",
+      proofServer: "http://127.0.0.1:6300",
+      walletSeed: "legacy-wallet-seed",
+    };
+
+    expect(Object.hasOwn(preFaucetConfig, "faucetUrl")).toBe(false);
+  });
+
+  test("stagenet uses the complete explicit Shielded Tools profile", () => {
+    expect(defaultMidnightNetworkConfig("stagenet")).toEqual({
+      indexer: "https://indexer.stagenet.shielded.tools/api/v4/graphql",
+      indexerWS: "wss://indexer.stagenet.shielded.tools/api/v4/graphql/ws",
+      node: "wss://rpc.stagenet.shielded.tools",
+      proofServer: "http://127.0.0.1:6300",
+      faucetUrl: "https://faucet.stagenet.shielded.tools/api/drips",
+      networkId: "stagenet",
+      genesisWalletSeed: "",
+    });
   });
 
-  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`);
+  test("undeployed retains the complete loopback v4 profile", () => {
+    expect(defaultMidnightNetworkConfig("undeployed")).toEqual({
+      indexer: "http://127.0.0.1:8088/api/v4/graphql",
+      indexerWS: "ws://127.0.0.1:8088/api/v4/graphql/ws",
+      node: "http://127.0.0.1:9944",
+      proofServer: "http://127.0.0.1:6300",
+      networkId: "undeployed",
+      genesisWalletSeed: "0000000000000000000000000000000000000000000000000000000000000001",
+    });
+  });
+
+  for (const networkId of ["preview", "preprod"] as const) {
+    test(`preserves node-1.x network ID ${networkId} without remapping`, () => {
+      expect(defaultMidnightNetworkConfig(networkId)).toEqual({
+        indexer: `https://indexer.${networkId}.midnight.network/api/v4/graphql`,
+        indexerWS: `wss://indexer.${networkId}.midnight.network/api/v4/graphql/ws`,
+        node: `https://rpc.${networkId}.midnight.network`,
+        proofServer: "http://127.0.0.1:6300",
+        networkId,
+        genesisWalletSeed: "",
+      });
     });
   }
+
+  test("preserves an arbitrary future network ID and hosted convention", () => {
+    expect(defaultMidnightNetworkConfig("future-network")).toEqual({
+      indexer: "https://indexer.future-network.midnight.network/api/v4/graphql",
+      indexerWS: "wss://indexer.future-network.midnight.network/api/v4/graphql/ws",
+      node: "https://rpc.future-network.midnight.network",
+      proofServer: "http://127.0.0.1:6300",
+      networkId: "future-network",
+      genesisWalletSeed: "",
+    });
+  });
+
+  test("selected stagenet defaults expose inert faucet metadata without fetch", async () => {
+    const moduleUrl = new URL("../src/midnight-env.ts", import.meta.url).href;
+    const probe = Bun.spawn([
+      process.execPath,
+      "--eval",
+      `
+        let networkCalls = 0;
+        globalThis.fetch = () => {
+          networkCalls += 1;
+          throw new Error("unexpected network call");
+        };
+        const { midnightNetworkConfig } = await import(${JSON.stringify(moduleUrl)});
+        console.log(JSON.stringify({ midnightNetworkConfig, networkCalls }));
+      `,
+    ], {
+      env: {
+        ...process.env,
+        MIDNIGHT_NETWORK_ID: "stagenet",
+        MIDNIGHT_INDEXER_HTTP: "",
+        MIDNIGHT_INDEXER_WS: "",
+        MIDNIGHT_NODE_HTTP: "",
+        MIDNIGHT_PROOF_SERVER_URL: "",
+        MIDNIGHT_PROOF_SERVER: "",
+        MIDNIGHT_WALLET_SEED: "",
+        MIDNIGHT_WALLET_MNEMONIC: "",
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [exitCode, stdout, stderr] = await Promise.all([
+      probe.exited,
+      new Response(probe.stdout).text(),
+      new Response(probe.stderr).text(),
+    ]);
+
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      midnightNetworkConfig: {
+        id: "stagenet",
+        indexer: "https://indexer.stagenet.shielded.tools/api/v4/graphql",
+        indexerWS: "wss://indexer.stagenet.shielded.tools/api/v4/graphql/ws",
+        node: "wss://rpc.stagenet.shielded.tools",
+        proofServer: "http://127.0.0.1:6300",
+        faucetUrl: "https://faucet.stagenet.shielded.tools/api/drips",
+        walletSeed: "",
+      },
+      networkCalls: 0,
+    });
+  });
+
+  test("selected stagenet environment overrides win while faucet stays inert", async () => {
+    const moduleUrl = new URL("../src/midnight-env.ts", import.meta.url).href;
+    const probe = Bun.spawn([
+      process.execPath,
+      "--eval",
+      `
+        let networkCalls = 0;
+        globalThis.fetch = () => {
+          networkCalls += 1;
+          throw new Error("unexpected network call");
+        };
+        const { midnightNetworkConfig } = await import(${JSON.stringify(moduleUrl)});
+        console.log(JSON.stringify({ midnightNetworkConfig, networkCalls }));
+      `,
+    ], {
+      env: {
+        ...process.env,
+        MIDNIGHT_NETWORK_ID: "stagenet",
+        MIDNIGHT_INDEXER_HTTP: "https://override.example/indexer",
+        MIDNIGHT_INDEXER_WS: "wss://override.example/indexer/ws",
+        MIDNIGHT_NODE_HTTP: "wss://override.example/node",
+        MIDNIGHT_PROOF_SERVER_URL: "http://override.example/proof",
+        MIDNIGHT_PROOF_SERVER: "http://ignored.example/proof",
+        MIDNIGHT_WALLET_SEED: "seed-override",
+        MIDNIGHT_WALLET_MNEMONIC: "invalid mnemonic must remain unused",
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [exitCode, stdout, stderr] = await Promise.all([
+      probe.exited,
+      new Response(probe.stdout).text(),
+      new Response(probe.stderr).text(),
+    ]);
+
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+    const { midnightNetworkConfig, networkCalls } = JSON.parse(stdout);
+    expect({
+      id: midnightNetworkConfig.id,
+      indexer: midnightNetworkConfig.indexer,
+      indexerWS: midnightNetworkConfig.indexerWS,
+      node: midnightNetworkConfig.node,
+      proofServer: midnightNetworkConfig.proofServer,
+      walletSeed: midnightNetworkConfig.walletSeed,
+    }).toEqual({
+      id: "stagenet",
+      indexer: "https://override.example/indexer",
+      indexerWS: "wss://override.example/indexer/ws",
+      node: "wss://override.example/node",
+      proofServer: "http://override.example/proof",
+      walletSeed: "seed-override",
+    });
+    expect(networkCalls).toBe(0);
+  });
 });