@effectstream/midnight-contracts 0.200.5 → 0.300.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/midnight-contracts",
-  "version": "0.200.5",
+  "version": "0.300.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -26,35 +26,34 @@
     "./types": "./src/types.ts"
   },
   "dependencies": {
-    "@effectstream/utils": "0.200.5",
-    "@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",
-    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-level-private-state-provider": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-network-id": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-protocol": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-types": "5.0.0-beta.6",
-    "@midnight-ntwrk/midnight-js-utils": "5.0.0-beta.6",
+    "@effectstream/utils": "0.300.0",
+    "@midnight-ntwrk/compact-js": "3.0.0",
+    "@midnight-ntwrk/compact-runtime": "0.21.0",
+    "@midnight-ntwrk/midnight-js-contracts": "5.0.0",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "5.0.0",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "5.0.0",
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": "5.0.0",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "5.0.0",
+    "@midnight-ntwrk/midnight-js-protocol": "5.0.0",
+    "@midnight-ntwrk/midnight-js-types": "5.0.0",
+    "@midnight-ntwrk/midnight-js-utils": "5.0.0",
     "@midnight-ntwrk/platform-js": "3.0.0",
-    "@midnightntwrk/ledger-v9": "1.0.0-rc.3",
-    "@midnightntwrk/onchain-runtime-v4": "4.0.0-rc.3",
-    "@midnightntwrk/wallet-sdk": "2.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-abstractions": "3.0.0-beta.0",
-    "@midnightntwrk/wallet-sdk-address-format": "4.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-capabilities": "4.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-dust-wallet": "5.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-facade": "5.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-hd": "3.1.0-beta.1",
-    "@midnightntwrk/wallet-sdk-indexer-client": "1.3.0-beta.1",
-    "@midnightntwrk/wallet-sdk-node-client": "2.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-prover-client": "2.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-runtime": "1.0.6-beta.0",
-    "@midnightntwrk/wallet-sdk-shielded": "4.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-unshielded-wallet": "4.0.0-beta.2",
-    "@midnightntwrk/wallet-sdk-utilities": "1.2.0",
+    "@midnightntwrk/ledger-v9": "1.0.0",
+    "@midnightntwrk/onchain-runtime-v4": "4.0.0",
+    "@midnightntwrk/wallet-sdk": "2.0.0",
+    "@midnightntwrk/wallet-sdk-abstractions": "3.0.0",
+    "@midnightntwrk/wallet-sdk-address-format": "4.0.0",
+    "@midnightntwrk/wallet-sdk-capabilities": "4.0.0",
+    "@midnightntwrk/wallet-sdk-dust-wallet": "5.0.0",
+    "@midnightntwrk/wallet-sdk-facade": "5.0.0",
+    "@midnightntwrk/wallet-sdk-hd": "4.0.0",
+    "@midnightntwrk/wallet-sdk-indexer-client": "2.0.0",
+    "@midnightntwrk/wallet-sdk-node-client": "2.0.0",
+    "@midnightntwrk/wallet-sdk-prover-client": "2.0.0",
+    "@midnightntwrk/wallet-sdk-runtime": "2.0.0",
+    "@midnightntwrk/wallet-sdk-shielded": "4.0.0",
+    "@midnightntwrk/wallet-sdk-unshielded-wallet": "4.0.0",
+    "@midnightntwrk/wallet-sdk-utilities": "1.3.0",
     "@scure/bip39": "^2.0.1",
     "bn.js": "5.2.3",
     "dotenv": "^16.4.7",

package/src/deploy-phased.ts

@@ -20,16 +20,22 @@
 
 import { readFileSync, writeFileSync, rmSync, readdirSync } from "node:fs";
 import * as path from "node:path";
-import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
-import { ContractExecutable } from "@midnight-ntwrk/compact-js";
+import {
+  CompiledContract,
+  ContractExecutable,
+  type Contract,
+} from "@midnight-ntwrk/compact-js";
 import {
   asContractAddress,
   exitResultOrError,
-  makeContractExecutableRuntime,
+  makeLedger9ContractExecutableRuntime,
   SucceedEntirely,
   type MidnightProviders,
 } from "@midnight-ntwrk/midnight-js-types";
-import { submitInsertVerifierKeyTx } from "@midnight-ntwrk/midnight-js-contracts";
+import {
+  submitInsertVerifierKeyTx,
+  type Ledger9ContractProviders,
+} from "@midnight-ntwrk/midnight-js-contracts";
 import {
   ContractDeploy,
   ContractState,
@@ -40,6 +46,7 @@ import {
 
 import { CONSTANTS } from "./constants.ts";
 import type { DeployConfig, WalletResult } from "./types.ts";
+import { adoptInWallet } from "./wallet-transaction.ts";
 
 const log = console;
 
@@ -110,7 +117,7 @@ function saveState(stateFilePath: string, state: PhasedDeploymentState): void {
 export async function deployMidnightContractPhased(
   providers: MidnightProviders,
   // deno-lint-ignore no-explicit-any
-  compiledContract: any,
+  compiledContract: CompiledContract.CompiledContract<Contract.Any, any>,
   config: DeployConfig,
   // deno-lint-ignore no-explicit-any
   deployArgs: any[] | undefined,
@@ -137,7 +144,7 @@ export async function deployMidnightContractPhased(
     const coinPublicKey = providers.walletProvider.getCoinPublicKey().toString();
 
     const contractExec = ContractExecutable.make(compiledContract);
-    const contractRuntime = makeContractExecutableRuntime(
+    const contractRuntime = makeLedger9ContractExecutableRuntime(
       providers.zkConfigProvider,
       { coinPublicKey, signingKey },
     );
@@ -170,7 +177,7 @@ export async function deployMidnightContractPhased(
     contractAddress = contractDeploy.address;
 
     const unprovenTx = Transaction.fromParts(
-      getNetworkId(),
+      providers.config.networkId,
       undefined,
       undefined,
       Intent.new(createTtl()).addDeploy(contractDeploy),
@@ -178,11 +185,7 @@ export async function deployMidnightContractPhased(
     log.info(`Deploying empty contract at address: ${contractAddress}`);
 
     const recipe = await walletResult.wallet.balanceUnprovenTransaction(
-      unprovenTx as any,
-      {
-        shieldedSecretKeys: walletResult.walletZswapSecretKeys as any,
-        dustSecretKey: walletResult.walletDustSecretKey as any,
-      },
+      await adoptInWallet(walletResult.wallet, "Unproven", unprovenTx),
       { ttl: createTtl() },
     );
     const signedRecipe = await walletResult.wallet.signRecipe(
@@ -205,12 +208,10 @@ export async function deployMidnightContractPhased(
     state.contractAddress = contractAddress;
     saveState(stateFilePath, state);
 
-    (providers.privateStateProvider as any).setContractAddress?.(contractAddress);
     if (config.privateStateId) {
-      await providers.privateStateProvider.set(
-        config.privateStateId as any,
-        privateState,
-      );
+      await providers.privateStateProvider
+        .forContract(contractAddress)
+        .set(config.privateStateId, privateState);
     }
     await providers.privateStateProvider.setSigningKey(
       contractAddress,
@@ -239,15 +240,15 @@ export async function deployMidnightContractPhased(
     for (let attempt = 1; ; attempt++) {
       try {
         const result = await submitInsertVerifierKeyTx(
-          providers,
+          providers as Ledger9ContractProviders,
           compiledContract,
           asContractAddress(contractAddress),
-          circuitId as any,
+          circuitId,
           verifierKey,
         );
-        if (result.status !== SucceedEntirely) {
+        if (result.public.status !== SucceedEntirely) {
           throw new Error(
-            `Insert verifier key for ${circuitId} returned status ${result.status}`,
+            `Insert verifier key for ${circuitId} returned status ${result.public.status}`,
           );
         }
         break;

package/src/deploy.ts

@@ -3,15 +3,17 @@
 // Single WASM instance for ContractState / ContractMaintenanceAuthority.
 import "@midnightntwrk/onchain-runtime-v4";
 
-import { setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { Buffer } from "node:buffer";
 import { statSync, readdirSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import { getEnv, cwd } from "@effectstream/utils/runtime";
-import { deployContract } from "@midnight-ntwrk/midnight-js-contracts";
+import {
+  deployContract,
+  type Ledger9ContractProviders,
+  type Ledger9DeployContractOptionsWithPrivateState,
+} from "@midnight-ntwrk/midnight-js-contracts";
 import type { PrivateStateId } from "@midnight-ntwrk/midnight-js-types";
-import { CompiledContract, type Witnesses, type Contract } from "@midnight-ntwrk/compact-js";
-import type { SigningKey } from "@midnightntwrk/ledger-v9";
+import { CompiledContract, type Contract } from "@midnight-ntwrk/compact-js";
 import type { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
 import * as path from "node:path";
 
@@ -20,6 +22,7 @@ const log = console;
 import { findContractDirectoryForDeploy } from "./read-contract.ts";
 import { mnemonicToSeed } from "./mnemonicToSeed.ts";
 import type { NetworkUrls, DeployConfig, WalletResult } from "./types.ts";
+export type { DeployConfig } from "./types.ts";
 import { buildWalletAndWaitForFunds, extractInitialOwnerFromWallet } from "./build-wallet.ts";
 import { configureMidnightNodeProviders } from "./providers.ts";
 import { deployMidnightContractPhased } from "./deploy-phased.ts";
@@ -140,8 +143,6 @@ export async function deployMidnightContract(
     `Preflight resolved endpoints -> indexerHttp=${resolvedNetworkUrls.indexer}, indexerWs=${resolvedNetworkUrls.indexerWS}, node=${resolvedNetworkUrls.node}, proofServer=${resolvedNetworkUrls.proofServer}, networkId=${resolvedNetworkId}`,
   );
 
-  setNetworkId(resolvedNetworkId);
-
   let walletResult: WalletResult | null = opts?.walletResult ?? null;
   let providers: Awaited<ReturnType<typeof configureMidnightNodeProviders>> | null = null;
 
@@ -211,6 +212,7 @@ export async function deployMidnightContract(
       deployPrivateStateStoreName,
       zkConfigPath,
       unshieldedKeystore,
+      resolvedNetworkId,
     );
     log.info("Providers configured.");
 
@@ -228,7 +230,7 @@ export async function deployMidnightContract(
     };
 
     // First, create the compiled contract
-    const MyCompiledContract = CompiledContract.make(
+    const MyCompiledContract = CompiledContract.make<Contract.Any>(
       resolvedConfig.contractName,
       resolvedConfig.contractClass,
     ).pipe(
@@ -252,28 +254,23 @@ export async function deployMidnightContract(
       );
       log.info("Contract deployed (phased).");
     } else {
-      const deployOptions: {
-        compiledContract: CompiledContract.CompiledContract<
-          Contract<undefined, Witnesses<undefined>>,
-          undefined,
-          never
-        >;
-        privateStateId: PrivateStateId;
-        initialPrivateState: Contract.PrivateState<any>;
-        signingKey?: SigningKey;
-        args: Contract.InitializeParameters<any>;
-      } = {
-        compiledContract: MyCompiledContract as any,
+      // The contract class is only known at run time, so the options are
+      // typed against `Contract.Any`. `privateStateId` and
+      // `initialPrivateState` are always given together (both defaulted
+      // above), which is the pairing the with-private-state overload requires.
+      const deployOptions = {
+        compiledContract: MyCompiledContract,
         privateStateId: resolvedConfig.privateStateId as PrivateStateId,
-        initialPrivateState:
-          resolvedConfig.initialPrivateState as Contract.PrivateState<any>,
+        initialPrivateState: resolvedConfig.initialPrivateState,
         args: (deployArgs && deployArgs.length > 0
           ? deployArgs
-          : []) as Contract.InitializeParameters<any>,
-        signingKey: undefined,
-      };
+          : []) as Contract.InitializeParameters<Contract.Any>,
+      } satisfies Ledger9DeployContractOptionsWithPrivateState<Contract.Any>;
 
-      const deployedContract = await deployContract(providers, deployOptions);
+      const deployedContract = await deployContract(
+        providers as Ledger9ContractProviders<Contract.Any>,
+        deployOptions,
+      );
       log.info("Contract deployed.");
       contractAddress = deployedContract.deployTxData.public.contractAddress;
     }

package/src/get-wallet-info-cli.ts

@@ -11,7 +11,6 @@
 import dotenv from "dotenv";
 import { parseArgs } from "node:util";
 import { nativeToken } from "@midnightntwrk/ledger-v9";
-import { setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import type { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
 import * as Rx from "rxjs";
 import type { NetworkUrls } from "./types.ts";
@@ -96,7 +95,6 @@ async function main() {
   log.info(`Indexer: ${indexer}`);
   log.info(`Indexer WS: ${indexerWS}`);
   log.info(`Node: ${node}`);
-  setNetworkId(networkId);
 
   try {
     log.info("Building wallet...");

package/src/get-wallet-info.ts

@@ -19,7 +19,6 @@ import {
 } from "@midnightntwrk/ledger-v9";
 
 const log = console;
-import { setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { Buffer } from "node:buffer";
 import * as Rx from "rxjs";
 import { HDWallet, Roles } from "@midnightntwrk/wallet-sdk-hd";
@@ -988,7 +987,6 @@ export async function buildWalletFacade(
   dustSerializedState?: string | null,
   options?: { stopAuxWalletsImmediately?: boolean },
 ): Promise<WalletResult> {
-  setNetworkId(networkId);
   const shieldedSeed = deriveSeedForRole(seed, Roles.Zswap);
   const dustSeed = deriveSeedForRole(seed, Roles.Dust);
   const unshieldedSeed = deriveSeedForRole(seed, Roles.NightExternal);
@@ -1013,7 +1011,13 @@ export async function buildWalletFacade(
       buildDustWallet(walletConfig, dustSeed, dustSerializedState),
   });
 
-  await wallet.start(zswapSecretKeys, dustSecretKey);
+  // wallet-sdk 2 starts every wallet from seeds: each ledger version derives
+  // its own keys from them, so the same identity holds across the v9 boundary.
+  await wallet.start({
+    shielded: shieldedSeed,
+    unshielded: unshieldedSeed,
+    dust: dustSeed,
+  });
 
   const stopAuxNow =
     syncMode === 'dust-only' && (options?.stopAuxWalletsImmediately ?? true);

package/src/midnight-env.ts

@@ -23,7 +23,6 @@ export type NetworkConfig = {
     indexerWS: string;
     node: string;
     proofServer: string;
-    faucetUrl?: string;
     networkId: NetworkId.NetworkId;
     genesisWalletSeed: string;
 }
@@ -48,26 +47,15 @@ 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. `undeployed` uses loopback
- * services, Stagenet uses its explicit Shielded Tools profile, and every other
- * deployed or future ID follows the hosted Midnight endpoint convention.
+ * services; every deployed or future ID (mainnet, preview, preprod, ...)
+ * follows the hosted Midnight endpoint convention.
  */
 export const defaultMidnightNetworkConfig = (
   networkId: NetworkId.NetworkId,
 ): NetworkConfig => {
   if (networkId === "undeployed") return undeployedNetworkConfig;
-  if (networkId === "stagenet") return stagenetNetworkConfig;
   return deployedNetworkConfig(networkId);
 };
 
@@ -90,7 +78,6 @@ export type MidnightNetworkConfig = {
   indexerWS: string;
   node: string;
   proofServer: string;
-  faucetUrl?: string;
   walletSeed: string;
 };
 
@@ -100,7 +87,6 @@ export const midnightNetworkConfig: MidnightNetworkConfig = {
   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,
 };
 

package/src/mod.ts

@@ -39,4 +39,11 @@ export {
 } from "./build-wallet.ts";
 export { readMidnightContract } from "./read-contract.ts";
 export { configureMidnightNodeProviders } from "./providers.ts";
+export {
+    activeProtocolVersion,
+    adoptInWallet,
+    finalizedFromWallet,
+    unwrapInWallet,
+} from "./wallet-transaction.ts";
+export type { WalletStage } from "./wallet-transaction.ts";
 export { midnightNetworkConfig } from "./midnight-env.ts";

package/src/providers.ts

@@ -4,7 +4,7 @@
 
 import { Buffer } from "node:buffer";
 import * as path from "node:path";
-import type { ZswapSecretKeys, DustSecretKey, CoinPublicKey, EncPublicKey, FinalizedTransaction, TransactionId } from "@midnightntwrk/ledger-v9";
+import type { ZswapSecretKeys, DustSecretKey } 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";
@@ -12,120 +12,124 @@ 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 {
+  createMidnightProviderFromHandlers,
+  createWalletProviderFromHandlers,
+  type MidnightProvider,
+  type MidnightProviders,
+  type NetworkId,
+  type WalletProvider,
+} from "@midnight-ntwrk/midnight-js-types";
 import type { WalletFacade } from "@midnightntwrk/wallet-sdk-facade";
 import type { NetworkUrls } from "./types.ts";
 import type { UnshieldedKeystore } from "@midnightntwrk/wallet-sdk-unshielded-wallet";
 import { CONSTANTS } from "./constants.ts";
-// import { Contract } from "@midnight-ntwrk/compact-js";
 import { getEnv } from "@effectstream/utils/runtime";
+import { adoptInWallet, finalizedFromWallet } from "./wallet-transaction.ts";
 
 /**
  * Create a TTL date for transactions
  */
 function createTtl(): Date {
-    return new Date(Date.now() + CONSTANTS.TTL_DURATION_MS);
-  }
+  return new Date(Date.now() + CONSTANTS.TTL_DURATION_MS);
+}
+
+/**
+ * Wallet and midnight providers backed by a wallet-sdk 2 `WalletFacade`.
+ *
+ * Ledger-v9 only: the v8 entries are `undefined`, so a v8 handle is refused by
+ * the providers with `ProviderEraUnsupportedError`. The facade balances with
+ * the key material it was started from, so no secret keys are passed here.
+ */
+function createWalletAndMidnightProviders(
+  wallet: WalletFacade,
+  zswapSecretKeys: ZswapSecretKeys,
+  unshieldedKeystore: UnshieldedKeystore,
+): { walletProvider: WalletProvider; midnightProvider: MidnightProvider } {
+  const walletProvider = createWalletProviderFromHandlers({
+    v8: undefined,
+    v9: async (tx, ttl) => {
+      const recipe = await wallet.balanceUnboundTransaction(
+        await adoptInWallet(wallet, "Unbound", tx),
+        { ttl: ttl ?? createTtl() },
+      );
+      const signedRecipe = await wallet.signRecipe(
+        recipe,
+        (payload) => unshieldedKeystore.signDataAsync(payload),
+      );
+      return finalizedFromWallet(wallet, await wallet.finalizeRecipe(signedRecipe));
+    },
+    getCoinPublicKey: () => zswapSecretKeys.coinPublicKey,
+    getEncryptionPublicKey: () => zswapSecretKeys.encryptionPublicKey,
+  });
+  const midnightProvider = createMidnightProviderFromHandlers({
+    v8: undefined,
+    v9: async (tx) =>
+      wallet.submitTransaction(await adoptInWallet(wallet, "Finalized", tx)),
+  });
+  return { walletProvider, midnightProvider };
+}
 
 /**
- * Create wallet and midnight provider adapter for WalletFacade
+ * Configure all providers needed for contract deployment and circuit calls.
  *
- * Implements the WalletProvider and MidnightProvider interfaces
- * as defined in @midnight-ntwrk/midnight-js-types v5.
+ * `walletZswapSecretKeys`, `dustSecretKey` and `walletDustSecretKey` are not
+ * read: wallet-sdk 2 balances with the keys the facade was started from.
+ * `networkId` becomes `providers.config.networkId`, the network every
+ * transaction built with these providers targets.
  */
-function createWalletAndMidnightProvider(
-    wallet: WalletFacade,
-    zswapSecretKeys: ZswapSecretKeys,
-    walletZswapSecretKeys: ZswapSecretKeys,
-    dustSecretKey: DustSecretKey,
-    walletDustSecretKey: DustSecretKey,
-    unshieldedKeystore: UnshieldedKeystore
-  ): WalletProvider & MidnightProvider {
-    return {
-      getCoinPublicKey(): CoinPublicKey {
-        console.log("✅ Getting coin public key", zswapSecretKeys.coinPublicKey);
-        return zswapSecretKeys.coinPublicKey;
-      },
-      getEncryptionPublicKey(): EncPublicKey {
-        console.log("✅ Getting encryption public key", zswapSecretKeys.encryptionPublicKey);
-        return zswapSecretKeys.encryptionPublicKey;
-      },
-      async balanceTx(
-        tx: UnboundTransaction,
-        ttl?: Date
-      ): Promise<FinalizedTransaction> {
-        console.log("✅ Balancing transaction", tx);
-        const unboundTransactionRecipe = await wallet.balanceUnboundTransaction(tx, {
-          shieldedSecretKeys: zswapSecretKeys, 
-          dustSecretKey: dustSecretKey,
-         }, { ttl: ttl ?? createTtl() } );
-        const signedRecipe = await wallet.signRecipe(
-          unboundTransactionRecipe,
-          (payload) => unshieldedKeystore.signDataAsync(payload),
-        );
-        return wallet.finalizeRecipe(signedRecipe);
-      },
-      submitTx(tx: FinalizedTransaction): Promise<TransactionId> {
-        console.log("✅ Submitting transaction", tx);
-        return wallet.submitTransaction(tx);
-      },
-    };
-  }
-  
-  /**
-   * Configure all providers needed for contract deployment
-   */
-  export async function configureMidnightNodeProviders(
-    wallet: WalletFacade,
-    zswapSecretKeys: ZswapSecretKeys,
-    walletZswapSecretKeys: ZswapSecretKeys,
-    dustSecretKey: DustSecretKey,
-    walletDustSecretKey: DustSecretKey,
-    networkUrls: Required<Omit<NetworkUrls, "id">>,
-    privateStateStoreName: string,
-    zkConfigPath: string,
-    unshieldedKeystore: UnshieldedKeystore
-  ): Promise<MidnightProviders> {
-    const signingKeyStoreName = `${privateStateStoreName}-signing-keys`;
-    const walletAndMidnightProvider = createWalletAndMidnightProvider(
-      wallet,
-      zswapSecretKeys,
-      walletZswapSecretKeys,
-      dustSecretKey,
-      walletDustSecretKey,
-      unshieldedKeystore
-    );
-    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,
-      // a minimal config with just walletProvider is sufficient and much faster:
-      //   levelPrivateStateProvider({ walletProvider })
-      // Omitting privateStateStoreName/midnightDbName avoids historical private state sync.
-      privateStateProvider: levelPrivateStateProvider({
-        midnightDbName: "midnight-level-db-deploy", // Use separate DB for deployment to avoid lock conflicts
-        privateStateStoreName,
-        signingKeyStoreName,
-        // walletProvider: walletAndMidnightProvider, // Use wallet's encryption key for private state
-        privateStoragePasswordProvider: async () => getEnv("MIDNIGHT_STORAGE_PASSWORD") ?? "YourPasswordMy1!",
-        accountId: Buffer.from(zswapSecretKeys.coinPublicKey).toString('hex'),
-      }), // Type assertion: runtime supports walletProvider even though types don't reflect it yet
-      publicDataProvider: indexerPublicDataProvider(
-        networkUrls.indexer,
-        networkUrls.indexerWS
-      ),
-      zkConfigProvider,
-      proofProvider: httpClientProofProvider(
-        networkUrls.proofServer,
-        zkConfigRegistry,
-      ),
-      walletProvider: walletAndMidnightProvider,
-      midnightProvider: walletAndMidnightProvider,
-    };
-  }
+export async function configureMidnightNodeProviders(
+  wallet: WalletFacade,
+  zswapSecretKeys: ZswapSecretKeys,
+  _walletZswapSecretKeys: ZswapSecretKeys,
+  _dustSecretKey: DustSecretKey,
+  _walletDustSecretKey: DustSecretKey,
+  networkUrls: Required<Omit<NetworkUrls, "id">>,
+  privateStateStoreName: string,
+  zkConfigPath: string,
+  unshieldedKeystore: UnshieldedKeystore,
+  networkId: NetworkId,
+): Promise<MidnightProviders> {
+  const signingKeyStoreName = `${privateStateStoreName}-signing-keys`;
+  const { walletProvider, midnightProvider } = createWalletAndMidnightProviders(
+    wallet,
+    zswapSecretKeys,
+    unshieldedKeystore,
+  );
+  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,
+    // a minimal config with just walletProvider is sufficient and much faster:
+    //   levelPrivateStateProvider({ walletProvider })
+    // Omitting privateStateStoreName/midnightDbName avoids historical private state sync.
+    privateStateProvider: levelPrivateStateProvider({
+      midnightDbName: "midnight-level-db-deploy", // Use separate DB for deployment to avoid lock conflicts
+      privateStateStoreName,
+      signingKeyStoreName,
+      privateStoragePasswordProvider: async () => getEnv("MIDNIGHT_STORAGE_PASSWORD") ?? "YourPasswordMy1!",
+      accountId: Buffer.from(zswapSecretKeys.coinPublicKey).toString("hex"),
+    }),
+    publicDataProvider: indexerPublicDataProvider(
+      networkUrls.indexer,
+      networkUrls.indexerWS,
+    ),
+    zkConfigProvider,
+    proofProvider: httpClientProofProvider(
+      networkUrls.proofServer,
+      zkConfigRegistry,
+    ),
+    walletProvider,
+    midnightProvider,
+    config: {
+      networkId,
+      ttlSeconds: CONSTANTS.TTL_DURATION_MS / 1000,
+    },
+  };
+}

package/src/wallet-transaction.ts

@@ -0,0 +1,107 @@
+// ============================================================================
+// Wallet transaction handles (ledger-v9)
+// ============================================================================
+//
+// midnight-js 5 hands providers era-tagged transaction handles, and wallet-sdk
+// 2 takes and returns sealed `WalletTransaction` handles. This module is the
+// bridge between the two, following the midnight-js 5.0.0 testkit
+// (`testkit-js/src/wallet/wallet-transaction.ts`), ledger-v9 only.
+
+import {
+  DefaultForkSchedule,
+  ProtocolVersion,
+  WalletTransaction,
+  type WalletFacade,
+} from "@midnightntwrk/wallet-sdk";
+// The wallet SDK's own copy of ledger-v9: whatever is handed to the SDK must be
+// decoded with the copy the SDK runs, or its classes refuse each other.
+import * as WalletLedger9 from "@midnightntwrk/wallet-sdk/ledger/v9";
+import * as Rx from "rxjs";
+
+type VersionedWallet = Pick<WalletFacade, "state">;
+
+/** The stages a transaction is handed to the wallet at. */
+export type WalletStage = "Unproven" | "Unbound" | "Finalized";
+
+type Serializable = { readonly serialize: () => Uint8Array };
+
+const walletDecoders: Readonly<Record<WalletStage, (bytes: Uint8Array) => Serializable>> = {
+  Unproven: (bytes) =>
+    WalletLedger9.Transaction.deserialize("signature", "pre-proof", "pre-binding", bytes),
+  Unbound: (bytes) =>
+    WalletLedger9.Transaction.deserialize("signature", "proof", "pre-binding", bytes),
+  Finalized: (bytes) =>
+    WalletLedger9.Transaction.deserialize("signature", "proof", "binding", bytes),
+};
+
+/** The protocol version the wallet facade is acting at right now. */
+export async function activeProtocolVersion(
+  wallet: VersionedWallet,
+): Promise<ProtocolVersion.ProtocolVersion> {
+  return (await Rx.firstValueFrom(wallet.state())).activeProtocolVersion;
+}
+
+/**
+ * The epoch the chain is in right now, which is the only one the wallet will
+ * unwrap into. Uses the facade's default fork schedule because the facade is
+ * configured without an explicit `forks` entry.
+ */
+async function activeEpoch(
+  wallet: VersionedWallet,
+): Promise<ProtocolVersion.ProtocolVersion.Range> {
+  return ProtocolVersion.epochOf(
+    await activeProtocolVersion(wallet),
+    DefaultForkSchedule.v9,
+  );
+}
+
+/**
+ * Hands a ledger-v9 transaction to the wallet SDK: decodes its bytes with the
+ * wallet SDK's ledger copy and seals them at the chain's active protocol
+ * version.
+ */
+export async function adoptInWallet<S extends WalletStage>(
+  wallet: VersionedWallet,
+  stage: S,
+  tx: { serialize(): Uint8Array },
+): Promise<WalletTransaction<S>> {
+  return WalletTransaction.adopt(
+    stage,
+    walletDecoders[stage](tx.serialize()),
+    await activeProtocolVersion(wallet),
+  );
+}
+
+/**
+ * Reads the transaction a wallet SDK handle carries, refusing a handle sealed
+ * for another epoch than the one the chain is in. The result is an object of
+ * the wallet SDK's ledger-v9 copy.
+ */
+export async function unwrapInWallet<T extends Serializable = WalletLedger9.Transaction<
+  WalletLedger9.Signaturish,
+  WalletLedger9.Proofish,
+  WalletLedger9.Bindingish
+>>(
+  wallet: VersionedWallet,
+  handle: WalletTransaction,
+): Promise<T> {
+  const unwrapped = WalletTransaction.unwrapWithin<T>(
+    handle,
+    await activeEpoch(wallet),
+  );
+  if (unwrapped._tag === "Left") {
+    throw unwrapped.left;
+  }
+  return unwrapped.right;
+}
+
+/**
+ * Reads the bytes of a finalized wallet SDK handle, refusing a handle sealed
+ * for another epoch than the one the chain is in.
+ */
+export async function finalizedFromWallet(
+  wallet: VersionedWallet,
+  handle: WalletTransaction<"Finalized">,
+): Promise<Uint8Array> {
+  return (await unwrapInWallet(wallet, handle)).serialize();
+}

package/test/integration-rc-stack.ts

@@ -82,10 +82,6 @@ try {
         amount: fundingAmount,
       }],
     }],
-    {
-      shieldedSecretKeys: source.zswapSecretKeys,
-      dustSecretKey: source.dustSecretKey,
-    },
     { ttl: new Date(Date.now() + 30 * 60 * 1_000) },
   );
   if (fundingRecipe.type !== "UNPROVEN_TRANSACTION") {

package/test/migration.test.ts

@@ -194,8 +194,8 @@ describe("wallet-v2 migration", () => {
 });
 
 describe("network defaults", () => {
-  test("public config type accepts the complete pre-faucet object shape", () => {
-    const preFaucetConfig: MidnightNetworkConfig = {
+  test("public config type accepts the complete object shape", () => {
+    const config: MidnightNetworkConfig = {
       id: "undeployed",
       indexer: "http://127.0.0.1:8088/api/v4/graphql",
       indexerWS: "ws://127.0.0.1:8088/api/v4/graphql/ws",
@@ -204,19 +204,14 @@ describe("network defaults", () => {
       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: "",
-    });
+    expect(Object.keys(config).sort()).toEqual([
+      "id",
+      "indexer",
+      "indexerWS",
+      "node",
+      "proofServer",
+      "walletSeed",
+    ]);
   });
 
   test("undeployed retains the complete loopback v4 profile", () => {
@@ -230,8 +225,8 @@ describe("network defaults", () => {
     });
   });
 
-  for (const networkId of ["preview", "preprod"] as const) {
-    test(`preserves node-1.x network ID ${networkId} without remapping`, () => {
+  for (const networkId of ["mainnet", "preview", "preprod"] as const) {
+    test(`hosted network ID ${networkId} follows the Midnight endpoint convention`, () => {
       expect(defaultMidnightNetworkConfig(networkId)).toEqual({
         indexer: `https://indexer.${networkId}.midnight.network/api/v4/graphql`,
         indexerWS: `wss://indexer.${networkId}.midnight.network/api/v4/graphql/ws`,
@@ -254,7 +249,7 @@ describe("network defaults", () => {
     });
   });
 
-  test("selected stagenet defaults expose inert faucet metadata without fetch", async () => {
+  test("selected mainnet defaults resolve without any network call", async () => {
     const moduleUrl = new URL("../src/midnight-env.ts", import.meta.url).href;
     const probe = Bun.spawn([
       process.execPath,
@@ -271,7 +266,7 @@ describe("network defaults", () => {
     ], {
       env: {
         ...process.env,
-        MIDNIGHT_NETWORK_ID: "stagenet",
+        MIDNIGHT_NETWORK_ID: "mainnet",
         MIDNIGHT_INDEXER_HTTP: "",
         MIDNIGHT_INDEXER_WS: "",
         MIDNIGHT_NODE_HTTP: "",
@@ -294,19 +289,18 @@ describe("network defaults", () => {
     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",
+        id: "mainnet",
+        indexer: "https://indexer.mainnet.midnight.network/api/v4/graphql",
+        indexerWS: "wss://indexer.mainnet.midnight.network/api/v4/graphql/ws",
+        node: "https://rpc.mainnet.midnight.network",
         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 () => {
+  test("selected network environment overrides win without any network call", async () => {
     const moduleUrl = new URL("../src/midnight-env.ts", import.meta.url).href;
     const probe = Bun.spawn([
       process.execPath,
@@ -323,7 +317,7 @@ describe("network defaults", () => {
     ], {
       env: {
         ...process.env,
-        MIDNIGHT_NETWORK_ID: "stagenet",
+        MIDNIGHT_NETWORK_ID: "mainnet",
         MIDNIGHT_INDEXER_HTTP: "https://override.example/indexer",
         MIDNIGHT_INDEXER_WS: "wss://override.example/indexer/ws",
         MIDNIGHT_NODE_HTTP: "wss://override.example/node",
@@ -353,7 +347,7 @@ describe("network defaults", () => {
       proofServer: midnightNetworkConfig.proofServer,
       walletSeed: midnightNetworkConfig.walletSeed,
     }).toEqual({
-      id: "stagenet",
+      id: "mainnet",
       indexer: "https://override.example/indexer",
       indexerWS: "wss://override.example/indexer/ws",
       node: "wss://override.example/node",