@effectstream/frontend-sdk 0.100.17 → 0.100.19

package/build.ts

@@ -22,6 +22,10 @@ function collectExternals(pkgPath: string) {
       }
     }
   }
+  // Peer deps are never bundled — treat all of them as external.
+  for (const name of Object.keys(pkg.peerDependencies ?? {})) {
+    externalDeps.add(name);
+  }
 }
 
 collectExternals(resolve(import.meta.dir, "package.json"));

package/dist/mod.js

@@ -18943,14 +18943,41 @@ class MidnightCrypto {
   verifyAddress = (address) => {
     return Value7.Check(TypeboxHelpers.Midnight.Address, address);
   };
-  verifySignature = async (signerAddress, message, signature) => {
+  verifySignature = async (signerAddress, message, sigStruct) => {
     try {
-      if (this.verifyAddress(signerAddress) && this.isMidnightSignature(signature)) {
-        console.log("TODO: MIDNIGHT SIGNATURE NYI:", { signerAddress, message, signature });
+      if (!this.verifyAddress(signerAddress))
+        return false;
+      if (typeof sigStruct !== "string")
+        return false;
+      if (!this.isMidnightSignature(sigStruct))
+        return false;
+      const parts = sigStruct.split("|");
+      if (parts.length !== 2)
+        return false;
+      const [signature, verifyingKey] = parts;
+      if (!signature || !verifyingKey)
+        return false;
+      const [ledgerMod, addrMod] = await Promise.all([
+        import("@midnight-ntwrk/ledger-v8"),
+        import("@midnight-ntwrk/wallet-sdk-address-format")
+      ]);
+      const expectedHexAddress = ledgerMod.addressFromKey(verifyingKey).toLowerCase();
+      let decodedHex;
+      try {
+        const bech323 = addrMod.MidnightBech32m.parse(signerAddress);
+        const decoded = addrMod.UnshieldedAddress.codec.decode(bech323.network, bech323);
+        decodedHex = decoded.hexString.toLowerCase();
+      } catch {
         return false;
       }
-    } catch {}
-    return false;
+      if (decodedHex !== expectedHexAddress)
+        return false;
+      const messageBytes = new TextEncoder().encode(message);
+      return ledgerMod.verifySignature(verifyingKey, messageBytes, signature);
+    } catch (err) {
+      console.error("[MidnightCrypto] error verifying signature:", err);
+      return false;
+    }
   };
   decodeAddress(address) {
     return Value7.Decode(TypeboxHelpers.Midnight.Address, address);
@@ -19399,6 +19426,125 @@ class EthersEvmProvider {
   };
 }
 
+// ../effectstream-sdk/wallets/src/evm/viem.ts
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient2,
+  http as http3
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+class ViemConnector {
+  provider;
+  static INSTANCE = undefined;
+  static instance() {
+    if (ViemConnector.INSTANCE == null) {
+      ViemConnector.INSTANCE = new ViemConnector;
+    }
+    return ViemConnector.INSTANCE;
+  }
+  connectFromPrivateKey = async (args) => {
+    const account = privateKeyToAccount2(args.privateKey);
+    const client = createWalletClient2({
+      account,
+      chain: args.chain,
+      transport: http3(args.rpcUrl)
+    });
+    this.provider = await ViemEvmProvider.init(client, account);
+    return this.provider;
+  };
+  connectExternal = async (conn) => {
+    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 = () => {
+    return this.provider;
+  };
+  getOrThrowProvider = () => {
+    if (this.provider == null) {
+      throw new Error("ViemConnector not initialized yet");
+    }
+    return this.provider;
+  };
+  isConnected = () => {
+    return this.provider != null;
+  };
+}
+
+class ViemEvmProvider {
+  conn;
+  account;
+  address;
+  constructor(conn, account, address) {
+    this.conn = conn;
+    this.account = account;
+    this.address = address;
+  }
+  static init = async (client, account, metadata) => {
+    const conn = {
+      api: client,
+      metadata: metadata ?? {
+        name: "viem-local",
+        displayName: "Viem (local)"
+      }
+    };
+    return new ViemEvmProvider(conn, account, account.address);
+  };
+  getConnection = () => {
+    return this.conn;
+  };
+  getAddress = () => {
+    return {
+      type: 0 /* EVM */,
+      address: this.address.toLowerCase()
+    };
+  };
+  signMessage = async (message) => {
+    if (this.account == null) {
+      throw new Error("ViemEvmProvider.signMessage: account is missing");
+    }
+    return await this.conn.api.signMessage({
+      account: this.account,
+      message
+    });
+  };
+  sendTransaction = async (tx) => {
+    if (this.account == null) {
+      throw new Error("ViemEvmProvider.sendTransaction: account is missing");
+    }
+    const toBigInt = (h) => h == null ? undefined : BigInt(h);
+    const hash = await this.conn.api.sendTransaction({
+      account: this.account,
+      to: tx.to,
+      data: tx.data,
+      value: toBigInt(tx.value),
+      gas: toBigInt(tx.gas),
+      gasPrice: toBigInt(tx.gasPrice),
+      maxFeePerGas: toBigInt(tx.maxFeePerGas),
+      maxPriorityFeePerGas: toBigInt(tx.maxPriorityFeePerGas)
+    });
+    if (typeof hash !== "string") {
+      throw new Error(`[ViemEvmProvider.sendTransaction] expected string tx hash, got ${typeof hash}`);
+    }
+    const chain = this.conn.api.chain;
+    const transport = this.conn.api.transport;
+    const publicClient = createPublicClient2({
+      chain: chain ?? undefined,
+      transport: http3(transport?.url)
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash
+    });
+    if (receipt.status !== "success") {
+      throw new Error(`[ViemEvmProvider.sendTransaction] tx ${hash} reverted on chain (status=${receipt.status})`);
+    }
+    return { txHash: hash };
+  };
+}
+
 // ../effectstream-sdk/wallets/src/evm/injected.ts
 import { utf8ToHex as utf8ToHex3 } from "web3-utils";
 import * as CHAINS from "viem/chains";
@@ -19824,8 +19970,102 @@ class CardanoProvider {
   };
 }
 
-// ../effectstream-sdk/wallets/src/polkadot/polkadot.ts
+// ../effectstream-sdk/wallets/src/cardano/local.ts
 import { utf8ToHex as utf8ToHex5 } from "web3-utils";
+
+class CardanoLocalConnector {
+  provider;
+  static INSTANCE = undefined;
+  static instance() {
+    if (CardanoLocalConnector.INSTANCE == null) {
+      CardanoLocalConnector.INSTANCE = new CardanoLocalConnector;
+    }
+    return CardanoLocalConnector.INSTANCE;
+  }
+  connectFromSeed = async (args) => {
+    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();
+    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, args.network);
+    lucid.selectWallet.fromSeed(seedPhrase);
+    const bech32Address = await lucid.wallet().address();
+    const hexAddress = await addressToHex(lucid, bech32Address);
+    const api = {
+      signData: async (address, payloadHex) => {
+        return await lucid.wallet().signMessage(address, payloadHex);
+      },
+      getUsedAddresses: async () => [hexAddress],
+      lucid,
+      seedPhrase
+    };
+    const conn = {
+      api,
+      metadata: {
+        name: "cardano-local",
+        displayName: "Cardano (local seed)"
+      }
+    };
+    this.provider = new CardanoLocalProvider(conn, {
+      bech32: bech32Address,
+      hex: hexAddress
+    });
+    return this.provider;
+  };
+  getProvider = () => {
+    return this.provider;
+  };
+  getOrThrowProvider = () => {
+    if (this.provider == null) {
+      throw new Error("CardanoLocalConnector not initialized yet");
+    }
+    return this.provider;
+  };
+  isConnected = () => {
+    return this.provider != null;
+  };
+}
+
+class CardanoLocalProvider {
+  conn;
+  address;
+  constructor(conn, address) {
+    this.conn = conn;
+    this.address = address;
+  }
+  getConnection = () => {
+    return this.conn;
+  };
+  getAddress = () => {
+    return {
+      type: 1 /* CARDANO */,
+      address: this.address.bech32
+    };
+  };
+  signMessage = async (message) => {
+    const hexMessage = utf8ToHex5(message).slice(2);
+    const { signature, key } = await this.conn.api.signData(this.address.bech32, hexMessage);
+    return `${signature}+${key}`;
+  };
+}
+async function addressToHex(lucid, bech32Address) {
+  const utilsMod = await import("@lucid-evolution/utils");
+  const details = utilsMod.getAddressDetails(bech32Address);
+  return details.address.hex;
+}
+
+// ../effectstream-sdk/wallets/src/polkadot/polkadot.ts
+import { utf8ToHex as utf8ToHex6 } from "web3-utils";
 class PolkadotConnector {
   provider;
   static INSTANCE = undefined;
@@ -19936,7 +20176,7 @@ class PolkadotProvider {
     if (this.conn.api.signer.signRaw == null) {
       throw new Error(`[polkadot] extension ${this.conn.metadata.name} does not support signRaw`);
     }
-    const hexMessage = utf8ToHex5(message);
+    const hexMessage = utf8ToHex6(message);
     const { signature } = await this.conn.api.signer.signRaw({
       address: this.getAddress().address,
       data: hexMessage,
@@ -20067,7 +20307,7 @@ class MinaProvider {
 
 // ../effectstream-sdk/wallets/src/avail/avail.ts
 init_buffer();
-import { utf8ToHex as utf8ToHex6 } from "web3-utils";
+import { utf8ToHex as utf8ToHex7 } from "web3-utils";
 import { u8aToHex as u8aToHex2 } from "@polkadot/util";
 
 class AvailConnector {
@@ -20126,7 +20366,7 @@ class AvailJsProvider {
     };
   };
   signMessage = async (message) => {
-    const hexMessage = utf8ToHex6(message);
+    const hexMessage = utf8ToHex7(message);
     const buffer = Buffer2.from(hexMessage.slice(2), "hex");
     const signature = this.conn.api.keyring.getPairs()[0].sign(buffer);
     return u8aToHex2(signature);
@@ -20230,7 +20470,7 @@ class MidnightProvider {
     this.address = address;
   }
   static init = async (conn) => {
-    const hexAddress = await MidnightProvider.fetchAddress(conn);
+    const hexAddress = await MidnightProvider.fetchAddress(conn, { type: "unshielded" });
     return new MidnightProvider(conn, hexAddress);
   };
   getConnection() {
@@ -20241,7 +20481,7 @@ class MidnightProvider {
       encoding: "text",
       keyType
     });
-    return signature.signature;
+    return `${signature.signature}|${signature.verifyingKey}`;
   };
   getAddress() {
     return {
@@ -20249,12 +20489,31 @@ class MidnightProvider {
       address: this.address
     };
   }
-  static fetchAddress = async (conn) => {
-    const addresses = await conn.api.getShieldedAddresses();
-    if (!addresses?.shieldedAddress) {
-      throw new Error("Midnight wallet did not return a shielded address");
+  static fetchAddress = async (conn, options = {}) => {
+    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;
   };
 }
 var isInitialApi = (api) => {
@@ -20268,37 +20527,210 @@ var connectWithNetwork = async (api, networkId) => {
   return await connect(networkId);
 };
 
+// ../effectstream-sdk/wallets/src/midnight/local.ts
+init_buffer();
+class MidnightLocalConnector {
+  provider;
+  static INSTANCE = undefined;
+  static instance() {
+    if (MidnightLocalConnector.INSTANCE == null) {
+      MidnightLocalConnector.INSTANCE = new MidnightLocalConnector;
+    }
+    return MidnightLocalConnector.INSTANCE;
+  }
+  connectFromSeed = async (args) => {
+    if (args.networkUrls != null) {
+      return await this.connectWithFacade(args, args.networkUrls);
+    }
+    return await this.connectSigningOnly(args);
+  };
+  connectSigningOnly = async (args) => {
+    const { hdMod, keystoreMod } = await loadKeystoreDeps();
+    const seed = args.seed ?? generateRandomHexSeed(32);
+    const unshieldedSeed = deriveUnshieldedSeed(hdMod, seed, hdMod.Roles.NightExternal);
+    const unshieldedKeystore = keystoreMod.createKeystore(unshieldedSeed, args.networkId);
+    const unshieldedAddress = unshieldedKeystore.getBech32Address().asString();
+    const verifyingKey = String(unshieldedKeystore.getPublicKey());
+    const api = {
+      signData: async (data, options) => {
+        const bytes = options.encoding === "hex" ? Buffer2.from(data, "hex") : Buffer2.from(data, "utf-8");
+        const signature = unshieldedKeystore.signData(bytes);
+        return {
+          data,
+          signature: String(signature),
+          verifyingKey
+        };
+      },
+      getShieldedAddresses: async () => {
+        throw new Error("MidnightLocal signing-only mode does not expose a shielded address. Pass `networkUrls` to connectFromSeed to build the full WalletFacade.");
+      },
+      seed,
+      verifyingKey,
+      unshieldedAddress
+    };
+    const conn = {
+      api,
+      metadata: {
+        name: "midnight-local",
+        displayName: "Midnight (local seed)"
+      }
+    };
+    this.provider = new MidnightLocalProvider(conn, unshieldedAddress, unshieldedKeystore);
+    return this.provider;
+  };
+  connectWithFacade = async (args, networkUrls) => {
+    const contractsMod = await import("@effectstream/midnight-contracts/wallet-info").catch(() => {
+      throw new Error("@effectstream/midnight-contracts is required when `networkUrls` is passed to MidnightLocal.connectFromSeed. Install it as a peer dependency.");
+    });
+    const { hdMod, keystoreMod } = await loadKeystoreDeps();
+    const seed = args.seed ?? generateRandomHexSeed(32);
+    const unshieldedSeed = deriveUnshieldedSeed(hdMod, seed, hdMod.Roles.NightExternal);
+    const unshieldedKeystore = keystoreMod.createKeystore(unshieldedSeed, args.networkId);
+    const verifyingKey = String(unshieldedKeystore.getPublicKey());
+    const fullNetworkUrls = {
+      indexer: networkUrls.indexer,
+      indexerWS: networkUrls.indexerWS,
+      node: networkUrls.node,
+      proofServer: networkUrls.proofServer,
+      id: networkUrls.id ?? args.networkId
+    };
+    const walletResult = await contractsMod.buildWalletFacade(fullNetworkUrls, seed, args.networkId, args.syncMode ?? "all");
+    const initialShielded = await contractsMod.getInitialShieldedState(walletResult.wallet.shielded);
+    const shieldedAddress = initialShielded.address.coinPublicKeyString();
+    const api = {
+      signData: async (data, options) => {
+        const bytes = options.encoding === "hex" ? Buffer2.from(data, "hex") : Buffer2.from(data, "utf-8");
+        const signature = unshieldedKeystore.signData(bytes);
+        return {
+          data,
+          signature: String(signature),
+          verifyingKey
+        };
+      },
+      getShieldedAddresses: async () => ({ shieldedAddress }),
+      seed,
+      verifyingKey,
+      unshieldedAddress: walletResult.unshieldedAddress,
+      walletFacade: walletResult.wallet,
+      dustAddress: walletResult.dustAddress,
+      shieldedAddress,
+      walletResult
+    };
+    const conn = {
+      api,
+      metadata: {
+        name: "midnight-local",
+        displayName: "Midnight (local seed, facade)"
+      }
+    };
+    this.provider = new MidnightLocalProvider(conn, walletResult.unshieldedAddress, unshieldedKeystore);
+    return this.provider;
+  };
+  getProvider = () => {
+    return this.provider;
+  };
+  getOrThrowProvider = () => {
+    if (this.provider == null) {
+      throw new Error("MidnightLocalConnector not initialized yet");
+    }
+    return this.provider;
+  };
+  isConnected = () => {
+    return this.provider != null;
+  };
+}
+
+class MidnightLocalProvider {
+  conn;
+  address;
+  unshieldedKeystore;
+  constructor(conn, address, unshieldedKeystore) {
+    this.conn = conn;
+    this.address = address;
+    this.unshieldedKeystore = unshieldedKeystore;
+  }
+  getConnection = () => {
+    return this.conn;
+  };
+  getAddress = () => {
+    return {
+      type: 5 /* MIDNIGHT */,
+      address: this.address
+    };
+  };
+  signMessage = async (message) => {
+    const signed = await this.conn.api.signData(message, { encoding: "text", keyType: "unshielded" });
+    return `${signed.signature}|${signed.verifyingKey}`;
+  };
+  getUnshieldedKeystore = () => this.unshieldedKeystore;
+}
+async function loadKeystoreDeps() {
+  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.");
+  });
+  return { hdMod, keystoreMod };
+}
+function deriveUnshieldedSeed(hdMod, seedHex, role) {
+  const seedBuffer = Buffer2.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 Buffer2.from(derivation.key);
+}
+function generateRandomHexSeed(byteLength2) {
+  const bytes = new Uint8Array(byteLength2);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // ../effectstream-sdk/wallets/src/utils.ts
 var WalletMode;
 ((WalletMode2) => {
   WalletMode2[WalletMode2["EvmInjected"] = 0] = "EvmInjected";
   WalletMode2[WalletMode2["EvmEthers"] = 1] = "EvmEthers";
-  WalletMode2[WalletMode2["Midnight"] = 2] = "Midnight";
-  WalletMode2[WalletMode2["Cardano"] = 3] = "Cardano";
-  WalletMode2[WalletMode2["Polkadot"] = 4] = "Polkadot";
-  WalletMode2[WalletMode2["Algorand"] = 5] = "Algorand";
-  WalletMode2[WalletMode2["Mina"] = 6] = "Mina";
-  WalletMode2[WalletMode2["AvailJs"] = 7] = "AvailJs";
+  WalletMode2[WalletMode2["EvmViem"] = 2] = "EvmViem";
+  WalletMode2[WalletMode2["Midnight"] = 3] = "Midnight";
+  WalletMode2[WalletMode2["MidnightLocal"] = 4] = "MidnightLocal";
+  WalletMode2[WalletMode2["Cardano"] = 5] = "Cardano";
+  WalletMode2[WalletMode2["CardanoLocal"] = 6] = "CardanoLocal";
+  WalletMode2[WalletMode2["Polkadot"] = 7] = "Polkadot";
+  WalletMode2[WalletMode2["Algorand"] = 8] = "Algorand";
+  WalletMode2[WalletMode2["Mina"] = 9] = "Mina";
+  WalletMode2[WalletMode2["AvailJs"] = 10] = "AvailJs";
 })(WalletMode ||= {});
 var WalletNameMap = {
   [0 /* EvmInjected */]: "EVM",
   [1 /* EvmEthers */]: "EVM",
-  [2 /* Midnight */]: "Midnight",
-  [3 /* Cardano */]: "Cardano",
-  [4 /* Polkadot */]: "Polkadot",
-  [5 /* Algorand */]: "Algorand",
-  [6 /* Mina */]: "Mina",
-  [7 /* AvailJs */]: "Avail"
+  [2 /* EvmViem */]: "EVM",
+  [3 /* Midnight */]: "Midnight",
+  [4 /* MidnightLocal */]: "Midnight",
+  [5 /* Cardano */]: "Cardano",
+  [6 /* CardanoLocal */]: "Cardano",
+  [7 /* Polkadot */]: "Polkadot",
+  [8 /* Algorand */]: "Algorand",
+  [9 /* Mina */]: "Mina",
+  [10 /* AvailJs */]: "Avail"
 };
 var WalletModeMap = {
   [0 /* EvmInjected */]: EvmInjectedConnector.instance(),
   [1 /* EvmEthers */]: EthersConnector.instance(),
-  [2 /* Midnight */]: MidnightConnector.instance(),
-  [3 /* Cardano */]: CardanoConnector.instance(),
-  [4 /* Polkadot */]: PolkadotConnector.instance(),
-  [5 /* Algorand */]: AlgorandConnector.instance(),
-  [6 /* Mina */]: MinaConnector.instance(),
-  [7 /* AvailJs */]: AvailConnector.instance()
+  [2 /* EvmViem */]: ViemConnector.instance(),
+  [3 /* Midnight */]: MidnightConnector.instance(),
+  [4 /* MidnightLocal */]: MidnightLocalConnector.instance(),
+  [5 /* Cardano */]: CardanoConnector.instance(),
+  [6 /* CardanoLocal */]: CardanoLocalConnector.instance(),
+  [7 /* Polkadot */]: PolkadotConnector.instance(),
+  [8 /* Algorand */]: AlgorandConnector.instance(),
+  [9 /* Mina */]: MinaConnector.instance(),
+  [10 /* AvailJs */]: AvailConnector.instance()
 };
 async function allInjectedWallets(config = {
   signatureSupport: true,
@@ -20308,11 +20740,11 @@ async function allInjectedWallets(config = {
   const transactionSupport = config.transactionSupport;
   const wallets = {
     [0 /* EvmInjected */]: EvmInjectedConnector.getWalletOptions(),
-    [3 /* Cardano */]: CardanoConnector.getWalletOptions(),
-    [4 /* Polkadot */]: await PolkadotConnector.getWalletOptions(),
-    [6 /* Mina */]: MinaConnector.getWalletOptions(),
-    [5 /* Algorand */]: signatureSupport ? [] : AlgorandConnector.getWalletOptions(),
-    [2 /* Midnight */]: signatureSupport ? [] : MidnightConnector.getWalletOptions()
+    [5 /* Cardano */]: CardanoConnector.getWalletOptions(),
+    [7 /* Polkadot */]: await PolkadotConnector.getWalletOptions(),
+    [9 /* Mina */]: MinaConnector.getWalletOptions(),
+    [8 /* Algorand */]: signatureSupport ? [] : AlgorandConnector.getWalletOptions(),
+    [3 /* Midnight */]: MidnightConnector.getWalletOptions()
   };
   return wallets;
 }
@@ -20334,6 +20766,28 @@ async function connectInjectedWallet(typeName, preference, connector) {
   }
   throw new Error("Invalid preference");
 }
+// ../effectstream-sdk/wallets/src/helpers/format-error.ts
+function formatError2(err) {
+  if (err == null)
+    return "";
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  if (typeof err === "object") {
+    const o = err;
+    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 {}
+  }
+  return String(err);
+}
+
 // ../effectstream-sdk/wallets/src/wallet-modes.ts
 function getWalletName(info) {
   if (info.preference == null)
@@ -20354,7 +20808,7 @@ async function connectInjected(typeName, loginInfo, connector) {
     console.log(`${typeName} Error while logging into wallet ${getWalletName(loginInfo) ?? "simple"}`);
     return {
       success: false,
-      errorMessage: err instanceof Error ? err.message : String(err)
+      errorMessage: formatError2(err)
     };
   }
 }
@@ -20362,20 +20816,23 @@ function getAddressType(mode) {
   switch (mode) {
     case 0 /* EvmInjected */:
     case 1 /* EvmEthers */:
+    case 2 /* EvmViem */:
       return 0 /* EVM */;
-    case 3 /* Cardano */:
+    case 5 /* Cardano */:
+    case 6 /* CardanoLocal */:
       return 1 /* CARDANO */;
-    case 4 /* Polkadot */:
+    case 7 /* Polkadot */:
       return 7 /* POLKADOT */;
-    case 5 /* Algorand */:
+    case 8 /* Algorand */:
       return 3 /* ALGORAND */;
-    case 6 /* Mina */:
+    case 9 /* Mina */:
       return 4 /* MINA */;
-    case 2 /* Midnight */:
+    case 3 /* Midnight */:
+    case 4 /* MidnightLocal */:
       return 5 /* MIDNIGHT */;
-    case 7 /* AvailJs */:
+    case 10 /* AvailJs */:
       return 6 /* AVAIL */;
-    case 4 /* Polkadot */:
+    case 7 /* Polkadot */:
       return 7 /* POLKADOT */;
     default:
       throw new Error(`Unsupported wallet mode: ${mode}`);
@@ -20406,6 +20863,28 @@ async function cardanoLoginWrapper(loginInfo) {
   };
 }
 
+// ../effectstream-sdk/wallets/src/cardano/wrapper-local.ts
+async function cardanoLocalLoginWrapper(loginInfo) {
+  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
+    };
+  } catch (err) {
+    console.log("cardanoLocalLoginWrapper: error while building local Cardano wallet");
+    return {
+      success: false,
+      errorMessage: formatError2(err)
+    };
+  }
+}
+
 // ../effectstream-sdk/wallets/src/evm/wrapper-injected.ts
 async function switchChain(chain) {
   if (!chain) {
@@ -20471,7 +20950,7 @@ async function connectWallet(loginInfo) {
     console.log(`ethersLoginWrapper: Error while logging into wallet name}`);
     return {
       success: false,
-      errorMessage: err instanceof Error ? err.message : String(err)
+      errorMessage: formatError2(err)
     };
   }
 }
@@ -20487,6 +20966,28 @@ async function ethersLoginWrapper(loginInfo) {
   };
 }
 
+// ../effectstream-sdk/wallets/src/evm/wrapper-viem.ts
+async function viemLoginWrapper(loginInfo) {
+  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
+    };
+  } catch (err) {
+    console.log("viemLoginWrapper: error while building local viem wallet");
+    return {
+      success: false,
+      errorMessage: formatError2(err)
+    };
+  }
+}
+
 // ../effectstream-sdk/wallets/src/mina/wrapper.ts
 async function minaLoginWrapper(loginInfo) {
   const loginResult = await connectInjected("minaLoginWrapper", loginInfo, MinaConnector.instance());
@@ -20518,7 +21019,7 @@ async function connectWallet2(loginInfo) {
     console.log(`availJsLoginWrapper: Error while logging into wallet name}`);
     return {
       success: false,
-      errorMessage: err.message ?? String(err)
+      errorMessage: formatError2(err)
     };
   }
 }
@@ -20541,6 +21042,27 @@ async function midnightLoginWrapper(loginInfo) {
   };
 }
 
+// ../effectstream-sdk/wallets/src/midnight/wrapper-local.ts
+async function midnightLocalLoginWrapper(loginInfo) {
+  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
+    };
+  } catch (err) {
+    console.log("midnightLocalLoginWrapper: error building local Midnight wallet");
+    return {
+      success: false,
+      errorMessage: formatError2(err)
+    };
+  }
+}
+
 // ../effectstream-sdk/wallets/src/wallets.ts
 async function walletLogin(loginInfo) {
   const provider = await login(loginInfo);
@@ -20563,31 +21085,79 @@ async function login(loginInfo) {
     case 1 /* EvmEthers */: {
       return await ethersLoginWrapper(loginInfo);
     }
-    case 3 /* Cardano */: {
+    case 2 /* EvmViem */: {
+      return await viemLoginWrapper(loginInfo);
+    }
+    case 5 /* Cardano */: {
       return await cardanoLoginWrapper(loginInfo);
     }
-    case 4 /* Polkadot */: {
+    case 6 /* CardanoLocal */: {
+      return await cardanoLocalLoginWrapper(loginInfo);
+    }
+    case 7 /* Polkadot */: {
       return await polkadotLoginWrapper(loginInfo);
     }
-    case 5 /* Algorand */: {
+    case 8 /* Algorand */: {
       return await algorandLoginWrapper(loginInfo);
     }
-    case 6 /* Mina */: {
+    case 9 /* Mina */: {
       return await minaLoginWrapper(loginInfo);
     }
-    case 7 /* AvailJs */: {
+    case 10 /* AvailJs */: {
       return await availJsLoginWrapper(loginInfo);
     }
-    case 2 /* Midnight */: {
+    case 3 /* Midnight */: {
       return await midnightLoginWrapper(loginInfo);
     }
+    case 4 /* MidnightLocal */: {
+      return await midnightLocalLoginWrapper(loginInfo);
+    }
     default:
       throw new Error(`Unsupported wallet mode: ${loginInfo.mode}`);
   }
 }
+// ../effectstream-sdk/wallets/src/helpers/pick-mode.ts
+function pickWalletMode(args) {
+  if (args.preferLocal) {
+    const mode2 = localModeFor(args.chain);
+    return { mode: mode2, ...args.localOptions };
+  }
+  const mode = injectedModeFor(args.chain);
+  return { mode, ...args.injectedOptions };
+}
+function localModeFor(chain) {
+  switch (chain) {
+    case "evm":
+      return 2 /* EvmViem */;
+    case "cardano":
+      return 6 /* CardanoLocal */;
+    case "midnight":
+      return 4 /* MidnightLocal */;
+  }
+}
+function injectedModeFor(chain) {
+  switch (chain) {
+    case "evm":
+      return 0 /* EvmInjected */;
+    case "cardano":
+      return 5 /* Cardano */;
+    case "midnight":
+      return 3 /* Midnight */;
+  }
+}
+// ../effectstream-sdk/wallets/src/helpers/local-icons.ts
+function encodeSvg(svg) {
+  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
+}
+function jsCircle(fill, textFill = "#ffffff") {
+  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>`;
+}
+var evmViemIcon = encodeSvg(jsCircle("#F97316"));
+var cardanoLocalIcon = encodeSvg(jsCircle("#0033AD"));
+var midnightLocalIcon = encodeSvg(jsCircle("#0A0A0A"));
 // ../effectstream-sdk/wallets/src/effectstream.ts
 import { numberToHex } from "viem";
-import { utf8ToHex as utf8ToHex7 } from "web3-utils";
+import { utf8ToHex as utf8ToHex8 } from "web3-utils";
 import { Web3 } from "web3";
 
 // ../effectstream-sdk/events/src/types.ts
@@ -21076,7 +21646,7 @@ async function sendSelfSequencedTransaction(wallet, conciseData, effectstreamCon
     throw new Error("Effectstream L2 is EVM contract.");
   }
   const evmProvider = wallet.provider;
-  const hexData = utf8ToHex7(JSON.stringify(conciseData));
+  const hexData = utf8ToHex8(JSON.stringify(conciseData));
   const effectstreamL2Contract = await effectstreamConfig.getEffectstreamL2Contract();
   const txData = effectstreamL2Contract.methods["effectstreamSubmitGameInput"](hexData).encodeABI();
   const tx = {
@@ -21186,7 +21756,12 @@ export {
   sendTransaction,
   sendSelfSequencedTransaction,
   sendBatcherTransaction,
+  pickWalletMode,
+  midnightLocalIcon,
   getAddressType,
+  formatError2 as formatError,
+  evmViemIcon,
+  cardanoLocalIcon,
   allInjectedWallets,
   accountPayload_,
   accountMessages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/frontend-sdk",
-  "version": "0.100.17",
+  "version": "0.100.19",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -27,7 +27,7 @@
     "build": "bun run build.ts"
   },
   "dependencies": {
-    "@effectstream/wallets": "0.100.17"
+    "@effectstream/wallets": "0.100.19"
   },
   "description": "React frontend SDK for EffectStream"
 }