@effectstream/wallets 0.100.16 → 0.100.18

package/README.md

@@ -57,7 +57,7 @@ const evmOptions = available[WalletMode.EvmInjected]; // [{ metadata, ... }, …
 ```
 
 > **Browser only.** This package depends on `window.ethereum`, the
-> Cardano CIP-30 API, etc. — it won't load in plain Node. Server-side
+> Cardano CIP-30 API, etc. - it won't load in plain Node. Server-side
 > signature verification is `@effectstream/crypto`.
 
 ## Inside EffectStream
@@ -76,14 +76,14 @@ Login + signing:
 
 - `walletLogin(args)`: top-level helper that discovers, connects, and produces a signed batcher login.
 - `EffectstreamConfig`: runtime config (chain URLs, batcher URL, ...) the helpers consume.
-- `signMessage(wallet, message)` — sign an arbitrary message with the connected wallet.
+- `signMessage(wallet, message)` - sign an arbitrary message with the connected wallet.
 
 Sending transactions:
 
 - `sendTransaction(wallet, conciseInput, opts?)`: submit through the batcher and (by default) wait for processing.
 - `sendBatcherTransaction(...)`: explicit batcher submission.
 - `sendSelfSequencedTransaction(...)` bypasses the batcher.
-- `waitForEffectstreamBlockProcessed(...)` — block-height poller used by the above.
+- `waitForEffectstreamBlockProcessed(...)` - block-height poller used by the above.
 
 Wallet discovery / identification:
 

package/package.json

@@ -1,22 +1,63 @@
 {
   "name": "@effectstream/wallets",
-  "version": "0.100.16",
+  "version": "0.100.18",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/PaimaStudios/paima-engine",
+    "url": "https://github.com/effectstream/effectstream",
     "directory": "packages/effectstream-sdk/wallets"
   },
   "bugs": {
-    "url": "https://github.com/PaimaStudios/paima-engine/issues"
+    "url": "https://github.com/effectstream/effectstream/issues"
+  },
+  "exports": {
+    ".": "./src/mod.ts",
+    "./evm-viem": "./src/evm/viem.ts",
+    "./cardano-local": "./src/cardano/local.ts",
+    "./midnight-local": "./src/midnight/local.ts"
+  },
+  "peerDependencies": {
+    "@lucid-evolution/lucid": "^0.4.29",
+    "@lucid-evolution/provider": "^0.1.90",
+    "@lucid-evolution/utils": "^0.1.66",
+    "@midnight-ntwrk/ledger-v8": "^8.0.3",
+    "@midnight-ntwrk/wallet-sdk-hd": "^3.0.1",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "^2.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@lucid-evolution/lucid": {
+      "optional": true
+    },
+    "@lucid-evolution/provider": {
+      "optional": true
+    },
+    "@lucid-evolution/utils": {
+      "optional": true
+    },
+    "@midnight-ntwrk/ledger-v8": {
+      "optional": true
+    },
+    "@midnight-ntwrk/wallet-sdk-hd": {
+      "optional": true
+    },
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@lucid-evolution/lucid": "^0.4.30",
+    "@lucid-evolution/provider": "^0.1.91",
+    "@lucid-evolution/utils": "^0.1.66",
+    "@midnight-ntwrk/ledger-v8": "8.0.3",
+    "@midnight-ntwrk/wallet-sdk-hd": "3.0.1",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "2.1.0"
   },
-  "exports": "./src/mod.ts",
   "dependencies": {
-    "@effectstream/concise": "0.100.16",
-    "@effectstream/crypto": "0.100.16",
-    "@effectstream/event-client": "0.100.16",
-    "@effectstream/utils": "0.100.16",
+    "@effectstream/concise": "0.100.18",
+    "@effectstream/crypto": "0.100.18",
+    "@effectstream/event-client": "0.100.18",
+    "@effectstream/utils": "0.100.18",
     "@aurowallet/mina-provider": "^1.0.12",
     "@metamask/providers": "^22.1.0",
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",

package/src/avail/wrapper.ts

@@ -3,6 +3,7 @@ import type { IProvider } from "../IProvider.ts";
 import type { WalletMode, ApiForMode } from "../utils.ts";
 import type { LoginInfoMap } from "../wallet-modes.ts";
 import { type AvailJsApi, AvailConnector } from "./avail.ts";
+import { formatError } from "../helpers/format-error.ts";
 
 // Problematic dependency for deno-fresh
 import { Keyring } from "avail-js-sdk";
@@ -31,7 +32,7 @@ async function connectWallet(
     console.log(`availJsLoginWrapper: Error while logging into wallet name}`);
     return {
       success: false,
-      errorMessage: err.message ?? String(err),
+      errorMessage: formatError(err),
     }
   }
 }

package/src/cardano/local.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { CryptoManager } from "@effectstream/crypto";
+import { AddressType } from "@effectstream/utils";
+import { CardanoLocalConnector } from "./local.ts";
+
+describe("CardanoLocalProvider", () => {
+  test("connect from seed produces a bech32 address", async () => {
+    const provider = await CardanoLocalConnector.instance().connectFromSeed({
+      network: "Preview",
+    });
+    const { type, address } = provider.getAddress();
+    expect(type).toBe(AddressType.CARDANO);
+    expect(address.startsWith("addr_test1")).toBe(true);
+  });
+
+  test("signMessage produces a signature that @effectstream/crypto verifies", async () => {
+    const provider = await CardanoLocalConnector.instance().connectFromSeed({
+      network: "Preview",
+    });
+    const message = "hello effectstream";
+    const signature = await provider.signMessage(message);
+
+    const cardanoCrypto = CryptoManager.getCryptoManager(AddressType.CARDANO);
+    const ok = await cardanoCrypto.verifySignature(
+      provider.getAddress().address,
+      message,
+      signature,
+    );
+    expect(ok).toBe(true);
+  });
+});

package/src/cardano/local.ts

@@ -0,0 +1,159 @@
+import { AddressType } from "@effectstream/utils";
+import { utf8ToHex } from "web3-utils";
+import type {
+  ActiveConnection,
+  AddressAndType,
+  IProvider,
+  UserSignature,
+} from "../IProvider.ts";
+import type { CardanoApi, CardanoAddress } from "./cardano.ts";
+
+export type CardanoLocalNetwork = "Mainnet" | "Preprod" | "Preview" | "Custom";
+
+export type CardanoLocalConnectArgs = {
+  /** BIP-39 mnemonic. Generated via `@lucid-evolution/utils#generateSeedPhrase` when omitted. */
+  seedPhrase?: string;
+  /** Cardano network — must match the chain address the signature is verified against. */
+  network: CardanoLocalNetwork;
+  /**
+   * Optional Lucid `Provider`. Pass when the caller wants Lucid to fetch UTxOs
+   * or submit transactions through this wallet. Pure signing does not require it.
+   */
+  provider?: unknown;
+};
+
+/**
+ * `getConnection().api` shape. Mirrors the CIP-30 subset that the rest of
+ * Effectstream's Cardano code consumes from a real injected wallet (signData,
+ * getUsedAddresses) so existing consumers work unchanged.
+ */
+export type CardanoLocalApi = {
+  /** CIP-30 signData. Returns COSE_Sign1 (signature) + COSE_Key (key) as hex. */
+  signData: (
+    address: string,
+    payloadHex: string,
+  ) => Promise<{ signature: string; key: string }>;
+  /** Hex-encoded address list, matching CIP-30 `getUsedAddresses`. */
+  getUsedAddresses: () => Promise<string[]>;
+  /** Underlying Lucid handle for callers that need tx-building. */
+  lucid: unknown;
+  /** Generated/passed seed phrase. Exposed so tests can persist/reuse the wallet. */
+  seedPhrase: string;
+};
+
+export class CardanoLocalConnector {
+  private provider: CardanoLocalProvider | undefined;
+  private static INSTANCE: undefined | CardanoLocalConnector = undefined;
+
+  static instance(): CardanoLocalConnector {
+    if (CardanoLocalConnector.INSTANCE == null) {
+      CardanoLocalConnector.INSTANCE = new CardanoLocalConnector();
+    }
+    return CardanoLocalConnector.INSTANCE;
+  }
+
+  connectFromSeed = async (
+    args: CardanoLocalConnectArgs,
+  ): Promise<CardanoLocalProvider> => {
+    const lucidMod = await import("@lucid-evolution/lucid").catch(() => {
+      throw new Error(
+        "@lucid-evolution/lucid is required for WalletMode.CardanoLocal. Install it as a peer dependency.",
+      );
+    });
+    const utilsMod = await import("@lucid-evolution/utils").catch(() => {
+      throw new Error(
+        "@lucid-evolution/utils is required for WalletMode.CardanoLocal. Install it as a peer dependency.",
+      );
+    });
+
+    const seedPhrase = args.seedPhrase ?? utilsMod.generateSeedPhrase();
+    // Lucid's wallet().address() requires a Provider to be set even for pure
+    // signing. When the caller doesn't supply one, fall back to an in-memory
+    // Emulator so signing-only flows (e2e tests, wallet-connect dry runs) work
+    // without standing up Blockfrost / YACI.
+    let provider = args.provider;
+    if (provider == null) {
+      const providerMod = await import("@lucid-evolution/provider").catch(() => {
+        throw new Error(
+          "@lucid-evolution/provider is required when no provider is supplied to CardanoLocal.",
+        );
+      });
+      provider = new providerMod.Emulator([]);
+    }
+    const lucid = await lucidMod.Lucid(provider as never, args.network);
+    lucid.selectWallet.fromSeed(seedPhrase);
+
+    const bech32Address = await lucid.wallet().address();
+    const hexAddress = await addressToHex(lucid, bech32Address);
+
+    const api: CardanoLocalApi = {
+      signData: async (address, payloadHex) => {
+        return await lucid.wallet().signMessage(address, payloadHex);
+      },
+      getUsedAddresses: async () => [hexAddress],
+      lucid,
+      seedPhrase,
+    };
+
+    const conn: ActiveConnection<CardanoApi> = {
+      api,
+      metadata: {
+        name: "cardano-local",
+        displayName: "Cardano (local seed)",
+      },
+    };
+
+    this.provider = new CardanoLocalProvider(conn, {
+      bech32: bech32Address,
+      hex: hexAddress,
+    });
+    return this.provider;
+  };
+
+  getProvider = (): undefined | CardanoLocalProvider => {
+    return this.provider;
+  };
+
+  getOrThrowProvider = (): CardanoLocalProvider => {
+    if (this.provider == null) {
+      throw new Error("CardanoLocalConnector not initialized yet");
+    }
+    return this.provider;
+  };
+
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class CardanoLocalProvider implements IProvider<CardanoApi> {
+  constructor(
+    private readonly conn: ActiveConnection<CardanoApi>,
+    readonly address: CardanoAddress,
+  ) {}
+
+  getConnection = (): ActiveConnection<CardanoApi> => {
+    return this.conn;
+  };
+
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.CARDANO,
+      address: this.address.bech32,
+    };
+  };
+
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const hexMessage = utf8ToHex(message).slice(2);
+    const { signature, key } = await (
+      this.conn.api as CardanoLocalApi
+    ).signData(this.address.bech32, hexMessage);
+    return `${signature}+${key}`;
+  };
+}
+
+async function addressToHex(lucid: any, bech32Address: string): Promise<string> {
+  const utilsMod = await import("@lucid-evolution/utils");
+  const details = utilsMod.getAddressDetails(bech32Address);
+  return details.address.hex;
+}

package/src/cardano/wrapper-local.ts

@@ -0,0 +1,31 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import type { LoginInfoMap } from "../wallet-modes.ts";
+import { CardanoLocalConnector } from "./local.ts";
+import { formatError } from "../helpers/format-error.ts";
+
+export async function cardanoLocalLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.CardanoLocal],
+): Promise<Result<IProvider<ApiForMode<WalletMode.CardanoLocal>>>> {
+  try {
+    console.log("cardanoLocalLoginWrapper: building Lucid wallet from seed");
+    const provider = await CardanoLocalConnector.instance().connectFromSeed({
+      seedPhrase: loginInfo.seedPhrase,
+      network: loginInfo.network,
+      provider: loginInfo.provider,
+    });
+    return {
+      success: true,
+      result: provider as unknown as IProvider<
+        ApiForMode<WalletMode.CardanoLocal>
+      >,
+    };
+  } catch (err) {
+    console.log("cardanoLocalLoginWrapper: error while building local Cardano wallet");
+    return {
+      success: false,
+      errorMessage: formatError(err),
+    };
+  }
+}

package/src/evm/viem.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { CryptoManager } from "@effectstream/crypto";
+import { AddressType } from "@effectstream/utils";
+import { ViemConnector } from "./viem.ts";
+
+const TEST_KEY =
+  "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" as const;
+const EXPECTED_ADDR = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266";
+
+describe("ViemEvmProvider", () => {
+  test("derives the hardhat default address from its private key", async () => {
+    const provider = await ViemConnector.instance().connectFromPrivateKey({
+      privateKey: TEST_KEY,
+      rpcUrl: "http://localhost:8545",
+    });
+    const { type, address } = provider.getAddress();
+    expect(type).toBe(AddressType.EVM);
+    expect(address).toBe(EXPECTED_ADDR);
+  });
+
+  test("signMessage produces a signature that @effectstream/crypto verifies", async () => {
+    const provider = await ViemConnector.instance().connectFromPrivateKey({
+      privateKey: TEST_KEY,
+      rpcUrl: "http://localhost:8545",
+    });
+    const message = "hello effectstream";
+    const signature = await provider.signMessage(message);
+
+    const evmCrypto = CryptoManager.getCryptoManager(AddressType.EVM);
+    const ok = await evmCrypto.verifySignature(
+      provider.getAddress().address,
+      message,
+      signature,
+    );
+    expect(ok).toBe(true);
+  });
+});

package/src/evm/viem.ts

@@ -0,0 +1,122 @@
+import {
+  createWalletClient,
+  http,
+  type Chain,
+  type Hex,
+  type PrivateKeyAccount,
+  type WalletClient,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { AddressType } from "@effectstream/utils";
+import type {
+  ActiveConnection,
+  AddressAndType,
+  IProvider,
+  UserSignature,
+} from "../IProvider.ts";
+import type { EvmAddress } from "./types.ts";
+
+export type ViemApi = WalletClient;
+
+export type ViemConnectArgs = {
+  privateKey: Hex;
+  rpcUrl: string;
+  chain?: Chain;
+};
+
+export class ViemConnector {
+  private provider: ViemEvmProvider | undefined;
+  private static INSTANCE: undefined | ViemConnector = undefined;
+
+  static instance(): ViemConnector {
+    if (ViemConnector.INSTANCE == null) {
+      ViemConnector.INSTANCE = new ViemConnector();
+    }
+    return ViemConnector.INSTANCE;
+  }
+
+  connectFromPrivateKey = async (
+    args: ViemConnectArgs,
+  ): Promise<ViemEvmProvider> => {
+    const account = privateKeyToAccount(args.privateKey);
+    const client = createWalletClient({
+      account,
+      chain: args.chain,
+      transport: http(args.rpcUrl),
+    });
+    this.provider = await ViemEvmProvider.init(client, account);
+    return this.provider;
+  };
+
+  connectExternal = async (
+    conn: ActiveConnection<ViemApi>,
+  ): Promise<ViemEvmProvider> => {
+    const account = conn.api.account;
+    if (account == null) {
+      throw new Error(
+        "ViemConnector.connectExternal: WalletClient.account is null. Build the client with createWalletClient({ account, ... }).",
+      );
+    }
+    this.provider = await ViemEvmProvider.init(conn.api, account, conn.metadata);
+    return this.provider;
+  };
+
+  getProvider = (): undefined | ViemEvmProvider => {
+    return this.provider;
+  };
+
+  getOrThrowProvider = (): ViemEvmProvider => {
+    if (this.provider == null) {
+      throw new Error("ViemConnector not initialized yet");
+    }
+    return this.provider;
+  };
+
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class ViemEvmProvider implements IProvider<ViemApi> {
+  constructor(
+    private readonly conn: ActiveConnection<ViemApi>,
+    private readonly account: PrivateKeyAccount | WalletClient["account"],
+    readonly address: EvmAddress,
+  ) {}
+
+  static init = async (
+    client: ViemApi,
+    account: NonNullable<WalletClient["account"]>,
+    metadata?: { name: string; displayName: string },
+  ): Promise<ViemEvmProvider> => {
+    const conn: ActiveConnection<ViemApi> = {
+      api: client,
+      metadata: metadata ?? {
+        name: "viem-local",
+        displayName: "Viem (local)",
+      },
+    };
+    return new ViemEvmProvider(conn, account, account.address as EvmAddress);
+  };
+
+  getConnection = (): ActiveConnection<ViemApi> => {
+    return this.conn;
+  };
+
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.EVM,
+      address: this.address.toLowerCase(),
+    };
+  };
+
+  signMessage = async (message: string): Promise<UserSignature> => {
+    if (this.account == null) {
+      throw new Error("ViemEvmProvider.signMessage: account is missing");
+    }
+    return await this.conn.api.signMessage({
+      account: this.account,
+      message,
+    });
+  };
+}

package/src/evm/wrapper-ethers.ts

@@ -3,6 +3,7 @@ import type { IProvider } from "../IProvider.ts";
 import type { WalletMode, ApiForMode } from "../utils.ts";
 import type { LoginInfoMap } from "../wallet-modes.ts";
 import { type EthersApi, EthersConnector } from "./ethers.ts";
+import { formatError } from "../helpers/format-error.ts";
 
 async function connectWallet(
   loginInfo: LoginInfoMap[WalletMode.EvmEthers]
@@ -22,7 +23,7 @@ async function connectWallet(
 
     return {
       success: false,
-      errorMessage: err instanceof Error ? err.message : String(err),
+      errorMessage: formatError(err),
     };
   }
 }

package/src/evm/wrapper-viem.ts

@@ -0,0 +1,31 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import type { LoginInfoMap } from "../wallet-modes.ts";
+import { type ViemApi, ViemConnector } from "./viem.ts";
+import { formatError } from "../helpers/format-error.ts";
+
+export async function viemLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.EvmViem],
+): Promise<Result<IProvider<ApiForMode<WalletMode.EvmViem>>>> {
+  try {
+    console.log("viemLoginWrapper: building viem WalletClient from private key");
+    const provider = await ViemConnector.instance().connectFromPrivateKey({
+      privateKey: loginInfo.privateKey,
+      rpcUrl: loginInfo.rpcUrl,
+      chain: loginInfo.chain,
+    });
+    return {
+      success: true,
+      result: provider as unknown as IProvider<ApiForMode<WalletMode.EvmViem>>,
+    };
+  } catch (err) {
+    console.log("viemLoginWrapper: error while building local viem wallet");
+    return {
+      success: false,
+      errorMessage: formatError(err),
+    };
+  }
+}
+
+export type { ViemApi };

package/src/helpers/format-error.ts

@@ -0,0 +1,31 @@
+/**
+ * Coerce anything a wallet/SDK can throw or reject with into a readable
+ * string.
+ *
+ * Wallet bridges return errors in three common shapes:
+ *   1. `Error` instances (most JS SDKs)
+ *   2. CIP-30-style `{ code: number, info: string }` (Midnight Lace, some
+ *      Cardano wallets, Mina/Auro)
+ *   3. Plain strings or numbers
+ *
+ * `String(obj)` on shape #2 yields the useless `"[object Object]"`, which
+ * leaks into UIs as "Error: [object Object]". This helper unpacks all three.
+ */
+export function formatError(err: unknown): string {
+  if (err == null) return "";
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (typeof err === "object") {
+    const o = err as { info?: string; message?: string; code?: number };
+    if (typeof o.info === "string") {
+      return o.code != null ? `${o.info} (code ${o.code})` : o.info;
+    }
+    if (typeof o.message === "string") return o.message;
+    try {
+      return JSON.stringify(err);
+    } catch {
+      // Cyclic objects land here.
+    }
+  }
+  return String(err);
+}

package/src/helpers/local-icons.ts

@@ -0,0 +1,35 @@
+/**
+ * Inline SVG icons for the three local-JS wallet modes.
+ *
+ * Each is a 32x32 circle filled with the chain's brand colour and the letters
+ * "JS" centered in white, so the wallets-ui (and templates) can distinguish
+ * the seed-driven local wallets from injected browser-extension wallets at a
+ * glance.
+ *
+ * Returned as `data:image/svg+xml` data URIs so they slot directly into
+ * `WalletOption.icon`, which the UI renders inside `<img>` tags.
+ */
+
+function encodeSvg(svg: string): string {
+  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
+}
+
+function jsCircle(fill: string, textFill = "#ffffff"): string {
+  return (
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">` +
+    `<circle cx="16" cy="16" r="16" fill="${fill}"/>` +
+    `<text x="16" y="21" text-anchor="middle" ` +
+    `font-family="Inter,-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif" ` +
+    `font-weight="700" font-size="13" fill="${textFill}">JS</text>` +
+    `</svg>`
+  );
+}
+
+/** Orange circle — EVM Viem local wallet. */
+export const evmViemIcon = encodeSvg(jsCircle("#F97316"));
+
+/** Cardano brand blue circle — Cardano Lucid local wallet. */
+export const cardanoLocalIcon = encodeSvg(jsCircle("#0033AD"));
+
+/** Near-black circle — Midnight local-seed wallet. */
+export const midnightLocalIcon = encodeSvg(jsCircle("#0A0A0A"));

package/src/helpers/pick-mode.ts

@@ -0,0 +1,89 @@
+import { WalletMode } from "../utils.ts";
+import type { LoginInfo, LoginInfoMap } from "../wallet-modes.ts";
+
+export type ChainKey = "evm" | "cardano" | "midnight";
+
+type StripMode<T> = T extends { mode: WalletMode } ? Omit<T, "mode"> : T;
+
+type LocalModeForChain<C extends ChainKey> = C extends "evm"
+  ? WalletMode.EvmViem
+  : C extends "cardano"
+  ? WalletMode.CardanoLocal
+  : C extends "midnight"
+  ? WalletMode.MidnightLocal
+  : never;
+
+type InjectedModeForChain<C extends ChainKey> = C extends "evm"
+  ? WalletMode.EvmInjected
+  : C extends "cardano"
+  ? WalletMode.Cardano
+  : C extends "midnight"
+  ? WalletMode.Midnight
+  : never;
+
+export type LocalOptionsForChain<C extends ChainKey> = StripMode<
+  LoginInfoMap[LocalModeForChain<C>]
+>;
+
+export type InjectedOptionsForChain<C extends ChainKey> = StripMode<
+  LoginInfoMap[InjectedModeForChain<C>]
+>;
+
+export type PickWalletModeArgs<C extends ChainKey> = {
+  chain: C;
+  /** True → return a local-wallet LoginInfo; false → injected. */
+  preferLocal: boolean;
+  /** Options for the local-wallet branch. Required because callers can't no-op a local wallet (it needs a seed/key). */
+  localOptions: LocalOptionsForChain<C>;
+  /** Options for the injected branch. Required so users always see the same wallet picker UX. */
+  injectedOptions: InjectedOptionsForChain<C>;
+};
+
+/**
+ * Pick between an injected (browser-extension) and a local (seed/key) wallet
+ * based on `preferLocal`, and return a ready-to-pass `LoginInfo` for
+ * `walletLogin()`. Both branches return the same `Wallet` shape from
+ * `walletLogin`, so the rest of the app does not need to branch on mode.
+ *
+ * Typical use (Vite frontend, headless test, etc.):
+ * ```ts
+ * const wallet = await walletLogin(pickWalletMode({
+ *   chain: "midnight",
+ *   preferLocal: import.meta.env.VITE_WALLET_MODE === "local",
+ *   localOptions: { seed, networkId },
+ *   injectedOptions: { preference: { name: "lace" }, networkId },
+ * }));
+ * ```
+ */
+export function pickWalletMode<C extends ChainKey>(
+  args: PickWalletModeArgs<C>,
+): LoginInfo {
+  if (args.preferLocal) {
+    const mode = localModeFor(args.chain);
+    return { mode, ...(args.localOptions as object) } as LoginInfo;
+  }
+  const mode = injectedModeFor(args.chain);
+  return { mode, ...(args.injectedOptions as object) } as LoginInfo;
+}
+
+function localModeFor(chain: ChainKey): WalletMode {
+  switch (chain) {
+    case "evm":
+      return WalletMode.EvmViem;
+    case "cardano":
+      return WalletMode.CardanoLocal;
+    case "midnight":
+      return WalletMode.MidnightLocal;
+  }
+}
+
+function injectedModeFor(chain: ChainKey): WalletMode {
+  switch (chain) {
+    case "evm":
+      return WalletMode.EvmInjected;
+    case "cardano":
+      return WalletMode.Cardano;
+    case "midnight":
+      return WalletMode.Midnight;
+  }
+}

package/src/midnight/local.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import { Buffer } from "node:buffer";
+import { AddressType } from "@effectstream/utils";
+import { verifySignature } from "@midnight-ntwrk/ledger-v8";
+import { CryptoManager } from "@effectstream/crypto";
+import { MidnightLocalConnector, type MidnightLocalApi } from "./local.ts";
+
+const DETERMINISTIC_SEED =
+  "0000000000000000000000000000000000000000000000000000000000000001";
+
+describe("MidnightLocalProvider", () => {
+  test("derives an unshielded bech32 address from a deterministic seed", async () => {
+    const provider = await MidnightLocalConnector.instance().connectFromSeed({
+      seed: DETERMINISTIC_SEED,
+      networkId: "undeployed",
+    });
+    const { type, address } = provider.getAddress();
+    expect(type).toBe(AddressType.MIDNIGHT);
+    expect(typeof address).toBe("string");
+    expect(address.length).toBeGreaterThan(0);
+  });
+
+  test("signMessage produces a signature that verifies via ledger-v8", async () => {
+    const provider = await MidnightLocalConnector.instance().connectFromSeed({
+      seed: DETERMINISTIC_SEED,
+      networkId: "undeployed",
+    });
+    const api = provider.getConnection().api as unknown as MidnightLocalApi;
+    const message = "hello effectstream";
+    const signed = await api.signData(message, {
+      encoding: "text",
+      keyType: "unshielded",
+    });
+
+    const messageBytes = Buffer.from(message, "utf-8");
+    const ok = verifySignature(
+      signed.verifyingKey as never,
+      messageBytes,
+      signed.signature as never,
+    );
+    expect(ok).toBe(true);
+
+    // signMessage on the IProvider surface returns "signature|verifyingKey"
+    // (Midnight signing is non-deterministic, so the inner signature differs
+    // each call). The combined form is what CryptoManager.Midnight() consumes.
+    const sig = await provider.signMessage(message);
+    const [innerSig, innerVk, ...rest] = sig.split("|");
+    expect(rest).toEqual([]);
+    expect(innerVk).toBe(signed.verifyingKey);
+    const okAgain = verifySignature(
+      innerVk as never,
+      messageBytes,
+      innerSig as never,
+    );
+    expect(okAgain).toBe(true);
+  });
+
+  test("signMessage round-trips through CryptoManager.Midnight().verifySignature", async () => {
+    const provider = await MidnightLocalConnector.instance().connectFromSeed({
+      seed: DETERMINISTIC_SEED,
+      networkId: "undeployed",
+    });
+    const message = "hello effectstream from @effectstream/crypto";
+    const sig = await provider.signMessage(message);
+
+    const midnightCrypto = CryptoManager.getCryptoManager(AddressType.MIDNIGHT);
+    const ok = await midnightCrypto.verifySignature(
+      provider.getAddress().address,
+      message,
+      sig,
+    );
+    expect(ok).toBe(true);
+
+    // Tampering with the message must fail verification.
+    const tampered = await midnightCrypto.verifySignature(
+      provider.getAddress().address,
+      `${message} tampered`,
+      sig,
+    );
+    expect(tampered).toBe(false);
+  });
+});

package/src/midnight/local.ts

@@ -0,0 +1,205 @@
+import { Buffer } from "node:buffer";
+import { AddressType, type MidnightAddress } from "@effectstream/utils";
+import type {
+  ActiveConnection,
+  AddressAndType,
+  IProvider,
+  UserSignature,
+} from "../IProvider.ts";
+import type { MidnightApi } from "./midnight.ts";
+
+export type MidnightLocalConnectArgs = {
+  /** 64-character hex seed. Generated when omitted. */
+  seed?: string;
+  /** Midnight network id — sets the bech32 prefix on the unshielded address. */
+  networkId: string;
+};
+
+/**
+ * Shape exposed on `getConnection().api`. A minimal subset of `ConnectedAPI`
+ * that the rest of Effectstream's Midnight code consumes:
+ *   - `signData` mirrors the dapp-connector-api shape.
+ *   - `getShieldedAddresses` is stubbed (shielded sync is out of scope for the
+ *     lite/seed-only path — callers that need shielded/dust addresses should
+ *     build the full WalletFacade via `@effectstream/midnight-contracts`).
+ */
+export type MidnightLocalApi = {
+  signData: (
+    data: string,
+    options: { encoding: "text" | "hex"; keyType: "unshielded" },
+  ) => Promise<{ data: string; signature: string; verifyingKey: string }>;
+  getShieldedAddresses: () => Promise<{ shieldedAddress: string }>;
+  /** The derived seed, exposed so tests can persist/reuse the wallet. */
+  seed: string;
+  /** Public verifying key for the unshielded signing role (hex). */
+  verifyingKey: string;
+  /** Bech32-encoded unshielded address. */
+  unshieldedAddress: string;
+};
+
+export class MidnightLocalConnector {
+  private provider: MidnightLocalProvider | undefined;
+  private static INSTANCE: undefined | MidnightLocalConnector = undefined;
+
+  static instance(): MidnightLocalConnector {
+    if (MidnightLocalConnector.INSTANCE == null) {
+      MidnightLocalConnector.INSTANCE = new MidnightLocalConnector();
+    }
+    return MidnightLocalConnector.INSTANCE;
+  }
+
+  /**
+   * Build a Midnight wallet identity from a hex seed.
+   *
+   * This is the "lite" / signing-only path: it derives the unshielded
+   * keystore from the seed and exposes a CIP-30-shaped `signData` backed by
+   * `unshieldedKeystore.signData(...)`. It does NOT bring up the shielded /
+   * dust wallets — that requires a live indexer + proof server and lives in
+   * `@effectstream/midnight-contracts`'s `buildWalletFacade`.
+   */
+  connectFromSeed = async (
+    args: MidnightLocalConnectArgs,
+  ): Promise<MidnightLocalProvider> => {
+    const hdMod = await import("@midnight-ntwrk/wallet-sdk-hd").catch(() => {
+      throw new Error(
+        "@midnight-ntwrk/wallet-sdk-hd is required for WalletMode.MidnightLocal.",
+      );
+    });
+    const keystoreMod = await import(
+      "@midnight-ntwrk/wallet-sdk-unshielded-wallet"
+    ).catch(() => {
+      throw new Error(
+        "@midnight-ntwrk/wallet-sdk-unshielded-wallet is required for WalletMode.MidnightLocal.",
+      );
+    });
+
+    const seed = args.seed ?? generateRandomHexSeed(32);
+    const unshieldedSeed = deriveUnshieldedSeed(
+      hdMod,
+      seed,
+      hdMod.Roles.NightExternal,
+    );
+    const unshieldedKeystore = keystoreMod.createKeystore(
+      unshieldedSeed,
+      args.networkId as never,
+    );
+
+    const unshieldedAddress = unshieldedKeystore.getBech32Address().asString();
+    const verifyingKey = String(unshieldedKeystore.getPublicKey());
+
+    const api: MidnightLocalApi = {
+      signData: async (data, options) => {
+        const bytes =
+          options.encoding === "hex"
+            ? Buffer.from(data, "hex")
+            : Buffer.from(data, "utf-8");
+        const signature = unshieldedKeystore.signData(bytes);
+        return {
+          data,
+          signature: String(signature),
+          verifyingKey,
+        };
+      },
+      getShieldedAddresses: async () => {
+        throw new Error(
+          "MidnightLocal lite mode does not expose a shielded address. Build a WalletFacade via @effectstream/midnight-contracts for shielded/dust support.",
+        );
+      },
+      seed,
+      verifyingKey,
+      unshieldedAddress,
+    };
+
+    const conn: ActiveConnection<MidnightApi> = {
+      api: api as unknown as MidnightApi,
+      metadata: {
+        name: "midnight-local",
+        displayName: "Midnight (local seed)",
+      },
+    };
+
+    this.provider = new MidnightLocalProvider(
+      conn,
+      unshieldedAddress as MidnightAddress,
+      unshieldedKeystore,
+    );
+    return this.provider;
+  };
+
+  getProvider = (): undefined | MidnightLocalProvider => {
+    return this.provider;
+  };
+
+  getOrThrowProvider = (): MidnightLocalProvider => {
+    if (this.provider == null) {
+      throw new Error("MidnightLocalConnector not initialized yet");
+    }
+    return this.provider;
+  };
+
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class MidnightLocalProvider implements IProvider<MidnightApi> {
+  constructor(
+    private readonly conn: ActiveConnection<MidnightApi>,
+    readonly address: MidnightAddress,
+    private readonly unshieldedKeystore: unknown,
+  ) {}
+
+  getConnection = (): ActiveConnection<MidnightApi> => {
+    return this.conn;
+  };
+
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.MIDNIGHT,
+      address: this.address,
+    };
+  };
+
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const signed = await (this.conn.api as unknown as MidnightLocalApi).signData(
+      message,
+      { encoding: "text", keyType: "unshielded" },
+    );
+    // Format: "signature|verifyingKey". Midnight signatures are not
+    // self-recovering (unlike EVM ECDSA), so the verifier needs the public
+    // key to call ledger-v8.verifySignature. Mirrors Cardano's "sig+key"
+    // convention, just with `|` as the separator to keep the formats distinct.
+    return `${signed.signature}|${signed.verifyingKey}`;
+  };
+
+  /** Expose the keystore for callers that need the raw signing primitive. */
+  getUnshieldedKeystore = (): unknown => this.unshieldedKeystore;
+}
+
+function deriveUnshieldedSeed(
+  hdMod: typeof import("@midnight-ntwrk/wallet-sdk-hd"),
+  seedHex: string,
+  role: import("@midnight-ntwrk/wallet-sdk-hd").Role,
+): Uint8Array {
+  const seedBuffer = Buffer.from(seedHex, "hex");
+  const hdResult = hdMod.HDWallet.fromSeed(seedBuffer);
+  if (hdResult.type !== "seedOk") {
+    throw new Error(`HDWallet.fromSeed failed: ${hdResult.type}`);
+  }
+  const derivation = hdResult.hdWallet
+    .selectAccount(0)
+    .selectRole(role)
+    .deriveKeyAt(0);
+  if (derivation.type !== "keyDerived") {
+    throw new Error(`HDWallet.deriveKeyAt failed: ${derivation.type}`);
+  }
+  return Buffer.from(derivation.key);
+}
+
+function generateRandomHexSeed(byteLength: number): string {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}

package/src/midnight/midnight.ts

@@ -132,11 +132,15 @@ export class MidnightProvider implements IProvider<MidnightApi> {
   static init = async (
     conn: ActiveConnection<MidnightApi>
   ): Promise<MidnightProvider> => {
-    const hexAddress = await MidnightProvider.fetchAddress(conn);
-    // const prefix = pickBech32Prefix(hexAddress);
-    // const words = bech32.toWords(hexStringToUint8Array(hexAddress));
-    // const userAddress = bech32.encode(prefix, words, 200);
-
+    // The IProvider's primary address must be the UNSHIELDED one — that's
+    // the address `addressFromKey(verifyingKey)` resolves to for the
+    // `signData({keyType: "unshielded"})` signatures we produce in
+    // `signMessage`, which is what `CryptoManager.Midnight().verifySignature`
+    // (and therefore the batcher) cross-checks. The shielded and dust
+    // addresses remain reachable via `fetchAddress(conn, { type })` or
+    // directly through `conn.api.getShieldedAddresses()` /
+    // `getDustAddress()`.
+    const hexAddress = await MidnightProvider.fetchAddress(conn, { type: "unshielded" });
     return new MidnightProvider(conn, hexAddress as MidnightAddress);
   };
 
@@ -152,7 +156,12 @@ export class MidnightProvider implements IProvider<MidnightApi> {
       encoding: "text",
       keyType,
     })) as Signature;
-    return signature.signature;
+    // Format: "signature|verifyingKey". Midnight unshielded signatures are
+    // not self-recovering, so `@effectstream/crypto`'s verifier needs the
+    // public key alongside the signature (matches the local-seed wallet
+    // and mirrors Cardano's "sig+key" convention with a different
+    // separator).
+    return `${signature.signature}|${signature.verifyingKey}`;
   };
 
   getAddress(): AddressAndType {
@@ -162,12 +171,49 @@ export class MidnightProvider implements IProvider<MidnightApi> {
     }
   }
 
-  static fetchAddress = async (conn: ActiveConnection<MidnightApi>): Promise<string> => {
-    const addresses = await conn.api.getShieldedAddresses();
-    if (!addresses?.shieldedAddress) {
-      throw new Error("Midnight wallet did not return a shielded address");
+  /**
+   * Fetch a specific address type from a connected Midnight wallet. Defaults
+   * to the **shielded** address to keep existing callers backwards-compatible
+   * with the pre-multi-address behaviour. The IProvider primary address
+   * (`getAddress()`) is the **unshielded** one — that's the address
+   * `addressFromKey(verifyingKey)` resolves to and what
+   * `CryptoManager.Midnight().verifySignature` needs to cross-check.
+   *
+   * @example
+   * ```ts
+   * const shielded = await MidnightProvider.fetchAddress(conn);
+   * const unshielded = await MidnightProvider.fetchAddress(conn, { type: "unshielded" });
+   * const dust = await MidnightProvider.fetchAddress(conn, { type: "dust" });
+   * ```
+   */
+  static fetchAddress = async (
+    conn: ActiveConnection<MidnightApi>,
+    options: { type?: "shielded" | "unshielded" | "dust" } = {},
+  ): Promise<string> => {
+    const type = options.type ?? "shielded";
+    switch (type) {
+      case "shielded": {
+        const res = await conn.api.getShieldedAddresses();
+        if (!res?.shieldedAddress) {
+          throw new Error("Midnight wallet did not return a shielded address");
+        }
+        return res.shieldedAddress;
+      }
+      case "unshielded": {
+        const res = await conn.api.getUnshieldedAddress();
+        if (!res?.unshieldedAddress) {
+          throw new Error("Midnight wallet did not return an unshielded address");
+        }
+        return res.unshieldedAddress;
+      }
+      case "dust": {
+        const res = await conn.api.getDustAddress();
+        if (!res?.dustAddress) {
+          throw new Error("Midnight wallet did not return a dust address");
+        }
+        return res.dustAddress;
+      }
     }
-    return addresses.shieldedAddress;
   };
 }
 

package/src/midnight/wrapper-local.ts

@@ -0,0 +1,30 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import type { LoginInfoMap } from "../wallet-modes.ts";
+import { MidnightLocalConnector } from "./local.ts";
+import { formatError } from "../helpers/format-error.ts";
+
+export async function midnightLocalLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.MidnightLocal],
+): Promise<Result<IProvider<ApiForMode<WalletMode.MidnightLocal>>>> {
+  try {
+    console.log("midnightLocalLoginWrapper: deriving unshielded keystore from seed");
+    const provider = await MidnightLocalConnector.instance().connectFromSeed({
+      seed: loginInfo.seed,
+      networkId: loginInfo.networkId,
+    });
+    return {
+      success: true,
+      result: provider as unknown as IProvider<
+        ApiForMode<WalletMode.MidnightLocal>
+      >,
+    };
+  } catch (err) {
+    console.log("midnightLocalLoginWrapper: error building local Midnight wallet");
+    return {
+      success: false,
+      errorMessage: formatError(err),
+    };
+  }
+}

package/src/mod.ts

@@ -7,4 +7,23 @@ export { WalletMode, WalletNameMap } from "./utils.ts";
 export { walletLogin } from "./wallets.ts";
 export { allInjectedWallets } from "./utils.ts";
 export { getAddressType } from "./wallet-modes.ts";
+export type { LoginInfo, LoginInfoMap } from "./wallet-modes.ts";
+// Local-wallet mode helper (env-driven injected↔local swap).
+export { pickWalletMode } from "./helpers/pick-mode.ts";
+export type {
+  ChainKey,
+  PickWalletModeArgs,
+  LocalOptionsForChain,
+  InjectedOptionsForChain,
+} from "./helpers/pick-mode.ts";
+// Inline data-URI icons for the three local-JS wallet modes (orange/blue/black
+// JS circles), suitable for use as `WalletOption.icon`.
+export {
+  evmViemIcon,
+  cardanoLocalIcon,
+  midnightLocalIcon,
+} from "./helpers/local-icons.ts";
+// Coerces wallet/SDK rejects (including CIP-30-style `{code, info}` objects)
+// to a readable string.
+export { formatError } from "./helpers/format-error.ts";
 export * from "./effectstream.ts";

package/src/utils.ts

@@ -7,18 +7,24 @@ import type {
 
 import { AlgorandConnector } from "./algorand/algorand.ts";
 import { EthersConnector } from "./evm/ethers.ts";
+import { ViemConnector } from "./evm/viem.ts";
 import { EvmInjectedConnector } from "./evm/injected.ts";
 import { CardanoConnector } from "./cardano/cardano.ts";
+import { CardanoLocalConnector } from "./cardano/local.ts";
 import { PolkadotConnector } from "./polkadot/polkadot.ts";
 import { MinaConnector } from "./mina/mina.ts";
 import { AvailConnector } from "./avail/avail.ts";
 import { MidnightConnector } from "./midnight/midnight.ts";
+import { MidnightLocalConnector } from "./midnight/local.ts";
 
 export const enum WalletMode {
   EvmInjected,
   EvmEthers,
+  EvmViem,
   Midnight,
+  MidnightLocal,
   Cardano,
+  CardanoLocal,
   Polkadot,
   Algorand,
   Mina,
@@ -28,8 +34,11 @@ export const enum WalletMode {
 export const WalletNameMap: Record<WalletMode, string> = {
   [WalletMode.EvmInjected]: "EVM",
   [WalletMode.EvmEthers]: "EVM",
+  [WalletMode.EvmViem]: "EVM",
   [WalletMode.Midnight]: "Midnight",
+  [WalletMode.MidnightLocal]: "Midnight",
   [WalletMode.Cardano]: "Cardano",
+  [WalletMode.CardanoLocal]: "Cardano",
   [WalletMode.Polkadot]: 'Polkadot',
   [WalletMode.Algorand]: 'Algorand',
   [WalletMode.Mina]: "Mina",
@@ -39,8 +48,11 @@ export const WalletNameMap: Record<WalletMode, string> = {
 export const WalletModeMap = {
   [WalletMode.EvmInjected]: EvmInjectedConnector.instance(),
   [WalletMode.EvmEthers]: EthersConnector.instance(),
+  [WalletMode.EvmViem]: ViemConnector.instance(),
   [WalletMode.Midnight]: MidnightConnector.instance(),
+  [WalletMode.MidnightLocal]: MidnightLocalConnector.instance(),
   [WalletMode.Cardano]: CardanoConnector.instance(),
+  [WalletMode.CardanoLocal]: CardanoLocalConnector.instance(),
   [WalletMode.Polkadot]: PolkadotConnector.instance(),
   [WalletMode.Algorand]: AlgorandConnector.instance(),
   [WalletMode.Mina]: MinaConnector.instance(),
@@ -87,9 +99,12 @@ export async function allInjectedWallets(config: {
     [WalletMode.Polkadot]: await PolkadotConnector.getWalletOptions(),
     [WalletMode.Mina]: MinaConnector.getWalletOptions(),
     // TODO: Algorand signature support is not implemented yet.
-    // NOTE: Midnight Do not support signature yet.
     [WalletMode.Algorand]: signatureSupport? [] : AlgorandConnector.getWalletOptions(),
-    [WalletMode.Midnight]: signatureSupport? [] : MidnightConnector.getWalletOptions(),
+    // Midnight signing via ConnectedAPI.signData(message, {keyType: "unshielded"})
+    // works as of @effectstream/crypto's MidnightCrypto.verifySignature
+    // implementation, so it now surfaces in the injected-wallet list even when
+    // signature support is requested.
+    [WalletMode.Midnight]: MidnightConnector.getWalletOptions(),
   };
 
   return wallets;

package/src/wallet-modes.ts

@@ -2,8 +2,11 @@ import type { ApiPromise } from "avail-js-sdk";
 import type { Result } from "@effectstream/utils";
 import type { AlgorandApi } from "./algorand/algorand.ts";
 import type { CardanoApi } from "./cardano/cardano.ts";
+import type { CardanoLocalNetwork } from "./cardano/local.ts";
 import type { EthersApi } from "./evm/ethers.ts";
+import type { ViemApi } from "./evm/viem.ts";
 import type { EvmApi } from "./evm/injected.ts";
+import type { Hex } from "viem";
 import type {
   ActiveConnection,
   IInjectedConnector,
@@ -17,7 +20,9 @@ import {
   WalletMode,
 } from "./utils.ts";
 import { AddressType } from "@effectstream/utils";
+import { formatError } from "./helpers/format-error.ts";
 import type { MidnightApi } from "./midnight/midnight.ts";
+import type {} from "./midnight/local.ts";
 import type { Chain } from "viem/chains";
 import { Wallet } from "ethers";
 
@@ -42,7 +47,25 @@ export type LoginInfoMap = {
     connection: ActiveConnection<EthersApi>;
     preferBatchedMode: boolean;
   };
+  [WalletMode.EvmViem]: {
+    /** 0x-prefixed 32-byte hex private key. */
+    privateKey: Hex;
+    /** RPC URL the viem WalletClient should target. */
+    rpcUrl: string;
+    /** Optional viem Chain — pass to enable chain-aware tx fields (chainId etc). */
+    chain?: Chain;
+    /** If true, even EVM inputs are batched (sign + send to batcher). */
+    preferBatchedMode?: boolean;
+  };
   [WalletMode.Cardano]: BaseLoginInfo<CardanoApi>;
+  [WalletMode.CardanoLocal]: {
+    /** BIP-39 mnemonic. Generated when omitted. */
+    seedPhrase?: string;
+    /** Cardano network — sets the bech32 prefix. */
+    network: CardanoLocalNetwork;
+    /** Optional Lucid Provider; only needed for on-chain ops, not pure signing. */
+    provider?: unknown;
+  };
   [WalletMode.Polkadot]: BaseLoginInfo<PolkadotApi>;
   [WalletMode.Algorand]: BaseLoginInfo<AlgorandApi>;
   [WalletMode.Mina]: BaseLoginInfo<MinaApi>;
@@ -54,6 +77,12 @@ export type LoginInfoMap = {
   [WalletMode.Midnight]: BaseLoginInfo<MidnightApi> & {
     networkId?: string;
   };
+  [WalletMode.MidnightLocal]: {
+    /** 64-char hex seed. Generated when omitted. */
+    seed?: string;
+    /** Midnight network id ("undeployed" | "testnet" | …) — sets the bech32 prefix. */
+    networkId: string;
+  };
 };
 
 type ToUnion<T> = {
@@ -93,7 +122,7 @@ export async function connectInjected<Api>(
 
     return {
       success: false,
-      errorMessage: err instanceof Error ? err.message : String(err),
+      errorMessage: formatError(err),
     };
   }
 }
@@ -103,8 +132,10 @@ export function getAddressType(mode: WalletMode): AddressType {
 
     case WalletMode.EvmInjected:
     case WalletMode.EvmEthers:
+    case WalletMode.EvmViem:
       return AddressType.EVM;
     case WalletMode.Cardano:
+    case WalletMode.CardanoLocal:
       return AddressType.CARDANO;
     case WalletMode.Polkadot:
       return AddressType.POLKADOT;
@@ -113,6 +144,7 @@ export function getAddressType(mode: WalletMode): AddressType {
     case WalletMode.Mina:
       return AddressType.MINA;
     case WalletMode.Midnight:
+    case WalletMode.MidnightLocal:
       return AddressType.MIDNIGHT;
     case WalletMode.AvailJs:
       return AddressType.AVAIL;

package/src/wallets.ts

@@ -1,9 +1,11 @@
 import type { IProvider } from "./IProvider.ts";
 import { algorandLoginWrapper } from "./algorand/wrapper.ts";
 import { cardanoLoginWrapper } from "./cardano/wrapper.ts";
+import { cardanoLocalLoginWrapper } from "./cardano/wrapper-local.ts";
 import { evmLoginWrapper } from "./evm/wrapper-injected.ts";
 import { polkadotLoginWrapper } from "./polkadot/wrapper.ts";
 import { ethersLoginWrapper } from "./evm/wrapper-ethers.ts";
+import { viemLoginWrapper } from "./evm/wrapper-viem.ts";
 import { minaLoginWrapper } from "./mina/wrapper.ts";
 import { availJsLoginWrapper } from "./avail/wrapper.ts";
 import { WalletMode } from "./utils.ts";
@@ -12,6 +14,7 @@ import type { Wallet } from "./types.ts";
 import type { LoginInfo } from "./wallet-modes.ts";
 // import { assertNever } from "assert-never";
 import { midnightLoginWrapper } from "./midnight/wrapper.ts";
+import { midnightLocalLoginWrapper } from "./midnight/wrapper-local.ts";
 
 export async function walletLogin(
   loginInfo: LoginInfo
@@ -38,9 +41,15 @@ async function login(loginInfo: LoginInfo): Promise<Result<IProvider<unknown>>>
     case WalletMode.EvmEthers: {
       return await ethersLoginWrapper(loginInfo);
     }
+    case WalletMode.EvmViem: {
+      return await viemLoginWrapper(loginInfo);
+    }
     case WalletMode.Cardano: {
       return await cardanoLoginWrapper(loginInfo);
     }
+    case WalletMode.CardanoLocal: {
+      return await cardanoLocalLoginWrapper(loginInfo);
+    }
     case WalletMode.Polkadot: {
       return await polkadotLoginWrapper(loginInfo);
     }
@@ -56,6 +65,9 @@ async function login(loginInfo: LoginInfo): Promise<Result<IProvider<unknown>>>
     case WalletMode.Midnight: {
       return await midnightLoginWrapper(loginInfo);
     }
+    case WalletMode.MidnightLocal: {
+      return await midnightLocalLoginWrapper(loginInfo);
+    }
     default:
       throw new Error(`Unsupported wallet mode: ${(loginInfo as any).mode}`);
   }