@moly-mcp/lido 1.0.6 → 1.0.8

package/dist/alerts-ARQAPRIT.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  configureAlertChannels,
+  listAlerts,
+  removeAlertById,
+  setAlert
+} from "./chunk-6UIRFWG4.js";
+import "./chunk-6F64RPQQ.js";
+import "./chunk-P6VFMSPM.js";
+import "./chunk-PDX44BCA.js";
+export {
+  configureAlertChannels,
+  listAlerts,
+  removeAlertById,
+  setAlert
+};

package/dist/bin.js

@@ -6,7 +6,8 @@ import {
   loadConfig,
   redactedConfig,
   saveConfig
-} from "./chunk-PIFEXJ56.js";
+} from "./chunk-P6VFMSPM.js";
+import "./chunk-PDX44BCA.js";
 
 // src/setup/wizard.ts
 import {
@@ -15,7 +16,6 @@ import {
   select,
   text,
   password,
-  confirm,
   note,
   cancel,
   isCancel
@@ -29,7 +29,7 @@ function check(value) {
   return value;
 }
 function clientSnippet(client) {
-  const entry = `"moly": { "command": "npx", "args": ["@moly/lido", "--server"] }`;
+  const entry = `"moly": { "command": "npx", "args": ["@moly-mcp/lido", "--server"] }`;
   switch (client) {
     case "claude-desktop":
       return `Add to ~/Library/Application Support/Claude/claude_desktop_config.json
@@ -73,6 +73,7 @@ var GEMINI_MODELS = [
   { value: "__custom__", label: "Enter custom model ID" }
 ];
 var OPENROUTER_MODELS = [
+  { value: "nvidia/nemotron-3-super-120b-a12b:free", label: "nvidia/nemotron-3-super-120b-a12b:free  (default, free)" },
   { value: "anthropic/claude-sonnet-4-6", label: "anthropic/claude-sonnet-4-6" },
   { value: "anthropic/claude-opus-4-6", label: "anthropic/claude-opus-4-6" },
   { value: "google/gemini-2.0-flash", label: "google/gemini-2.0-flash" },
@@ -95,7 +96,7 @@ async function pickModel(provider) {
   return picked;
 }
 async function runWizard() {
-  intro("  Moly \u2014 Lido MCP Server  \u2B21");
+  intro("  Moly  -  Lido MCP Server");
   const network = check(
     await select({
       message: "Which network?",
@@ -105,6 +106,18 @@ async function runWizard() {
       ]
     })
   );
+  let chainScope = "ethereum";
+  if (network === "mainnet") {
+    chainScope = check(
+      await select({
+        message: "Chain scope?",
+        options: [
+          { value: "ethereum", label: "Ethereum only  (L1 staking, governance, wrapping)" },
+          { value: "all", label: "All chains  (L1 + Base/Arbitrum bridging via LI.FI)" }
+        ]
+      })
+    );
+  }
   const rpcInput = check(
     await text({
       message: "Custom RPC URL?  (optional \u2014 leave blank to use public RPC)",
@@ -122,13 +135,46 @@ async function runWizard() {
     })
   );
   let privateKey = null;
-  const wantsKey = check(
-    await confirm({
-      message: "Add a private key?  (needed for Live mode \u2014 stored locally with chmod 600)",
-      initialValue: mode === "live"
+  let ows = null;
+  const keySource = check(
+    await select({
+      message: "Key source?  (needed for Live mode)",
+      options: [
+        { value: "ows", label: "OWS Wallet  (encrypted via Open Wallet Standard)" },
+        { value: "raw", label: "Raw private key  (stored in ~/.moly/config.json, chmod 600)" },
+        { value: "none", label: "None / Skip" }
+      ]
     })
   );
-  if (wantsKey) {
+  if (keySource === "ows") {
+    let wallets = [];
+    try {
+      const owsSdk = await import("@open-wallet-standard/core");
+      wallets = owsSdk.listWallets();
+    } catch {
+      note("Could not load OWS. Install it first:\ncurl -fsSL https://openwallet.sh/install.sh | bash\nnpm install @open-wallet-standard/core", "OWS not found");
+    }
+    if (wallets.length > 0) {
+      const walletName = check(
+        await select({
+          message: "Which OWS wallet?",
+          options: wallets.map((w) => ({
+            value: w.name,
+            label: `${w.name}  (${w.address.slice(0, 8)}...)`
+          }))
+        })
+      );
+      const passphrase = check(
+        await password({
+          message: "OWS passphrase:",
+          mask: "*"
+        })
+      );
+      ows = { walletName, passphrase: passphrase.trim() };
+    } else if (wallets.length === 0) {
+      note('No OWS wallets found. Create one first:\nows wallet create --name "moly"', "Empty vault");
+    }
+  } else if (keySource === "raw") {
     const pk = check(
       await password({
         message: "Private key (0x...):",
@@ -176,7 +222,9 @@ async function runWizard() {
     mode,
     rpc,
     privateKey,
+    ows,
     ai,
+    chainScope,
     setupComplete: true
   };
   saveConfig(cfg);
@@ -206,7 +254,7 @@ async function main() {
     case "setup": {
       const { cfg, terminalMode } = await runWizard();
       if (terminalMode) {
-        const { startChatSession } = await import("./session-RFQTJ6WZ.js");
+        const { startChatSession } = await import("./session-37TYTCEU.js");
         await startChatSession(cfg);
       } else {
         await startServer();
@@ -216,7 +264,7 @@ async function main() {
     // ── moly config ───────────────────────────────────────────────────
     case "config": {
       if (!configExists()) {
-        console.log("No config found. Run: npx @moly/lido");
+        console.log("No config found. Run: npx @moly-mcp/lido");
         process.exit(1);
       }
       const cfg = loadConfig();
@@ -232,14 +280,229 @@ async function main() {
         process.exit(0);
       }
       deleteConfig();
-      console.log("Config deleted. Run: npx @moly/lido  to set up again.");
+      console.log("Config deleted. Run: npx @moly-mcp/lido  to set up again.");
+      break;
+    }
+    // ── moly alert ─────────────────────────────────────────────────────
+    case "alert": {
+      const sub = args[1];
+      const getFlag = (flag) => {
+        const i = args.indexOf(flag);
+        return i !== -1 ? args[i + 1] : void 0;
+      };
+      switch (sub) {
+        case "add": {
+          const condition = args[2];
+          if (!condition) {
+            console.log("Usage: moly alert add <condition> [threshold] [--channel webhook]");
+            break;
+          }
+          const threshold = args[3] && !args[3].startsWith("-") ? parseFloat(args[3]) : void 0;
+          const channel = getFlag("--channel") ?? "telegram";
+          const { setAlert } = await import("./alerts-ARQAPRIT.js");
+          const alert = setAlert({ condition, threshold, channel });
+          console.log("Alert created:", JSON.stringify(alert, null, 2));
+          break;
+        }
+        case "list": {
+          const { listAlerts } = await import("./alerts-ARQAPRIT.js");
+          console.log(JSON.stringify(listAlerts(), null, 2));
+          break;
+        }
+        case "remove": {
+          const id = args[2];
+          if (!id) {
+            console.log("Usage: moly alert remove <id>");
+            break;
+          }
+          const { removeAlertById } = await import("./alerts-ARQAPRIT.js");
+          console.log(JSON.stringify(removeAlertById(id), null, 2));
+          break;
+        }
+        case "channels": {
+          const { configureAlertChannels } = await import("./alerts-ARQAPRIT.js");
+          const result = configureAlertChannels({
+            telegram_token: getFlag("--telegram-token"),
+            telegram_chat_id: getFlag("--telegram-chat"),
+            webhook_url: getFlag("--webhook-url")
+          });
+          console.log("Channels configured:", JSON.stringify(result, null, 2));
+          break;
+        }
+        case "daemon": {
+          if (!configExists()) {
+            console.log("No config. Run: moly setup");
+            process.exit(1);
+          }
+          const { runDaemon } = await import("./daemon-GU45VVNU.js");
+          await runDaemon();
+          break;
+        }
+        case "start": {
+          const { spawn } = await import("child_process");
+          const child = spawn(process.argv[0], [process.argv[1], "alert", "daemon"], {
+            detached: true,
+            stdio: "ignore"
+          });
+          child.unref();
+          console.log(`Alert daemon started (PID: ${child.pid})`);
+          break;
+        }
+        default:
+          console.log("Usage: moly alert <add|list|remove|channels|daemon|start>");
+      }
+      break;
+    }
+    // ── moly monitor ──────────────────────────────────────────────────
+    case "monitor": {
+      const sub = args[1];
+      switch (sub) {
+        case "start": {
+          const { spawn } = await import("child_process");
+          const child = spawn(process.argv[0], [process.argv[1], "alert", "daemon"], {
+            detached: true,
+            stdio: "ignore"
+          });
+          child.unref();
+          console.log(`Monitor daemon started (PID: ${child.pid})`);
+          break;
+        }
+        case "status": {
+          const { loadAlerts } = await import("./store-SKFUVSK4.js");
+          const data = loadAlerts();
+          if (!data.daemonPid) {
+            console.log("No daemon running (or never started).");
+          } else {
+            let alive = false;
+            try {
+              process.kill(data.daemonPid, 0);
+              alive = true;
+            } catch {
+            }
+            console.log(`PID: ${data.daemonPid}  alive: ${alive}`);
+            if (data.daemonStartedAt) console.log(`Started: ${data.daemonStartedAt}`);
+            if (data.lastCheckAt) console.log(`Last check: ${data.lastCheckAt}`);
+            console.log(`Active alerts: ${data.alerts.filter((a) => a.enabled).length}`);
+          }
+          break;
+        }
+        case "stop": {
+          const { loadAlerts, saveAlerts } = await import("./store-SKFUVSK4.js");
+          const data = loadAlerts();
+          if (!data.daemonPid) {
+            console.log("No daemon PID recorded.");
+            break;
+          }
+          try {
+            process.kill(data.daemonPid, "SIGTERM");
+            console.log(`Sent SIGTERM to PID ${data.daemonPid}`);
+          } catch {
+            console.log(`PID ${data.daemonPid} not running.`);
+          }
+          data.daemonPid = void 0;
+          saveAlerts(data);
+          break;
+        }
+        default:
+          console.log("Usage: moly monitor <start|status|stop>");
+      }
+      break;
+    }
+    // ── moly bounds ──────────────────────────────────────────────────
+    case "bounds": {
+      const sub = args[1];
+      const getFlag = (flag) => {
+        const i = args.indexOf(flag);
+        return i !== -1 ? args[i + 1] : void 0;
+      };
+      switch (sub) {
+        case "show":
+        case void 0: {
+          const { loadBounds } = await import("./store-5CEITPDY.js");
+          console.log(JSON.stringify(loadBounds(), null, 2));
+          break;
+        }
+        case "set": {
+          const { loadBounds, saveBounds } = await import("./store-5CEITPDY.js");
+          const b = loadBounds();
+          const mst = getFlag("--max-stake-per-tx");
+          const mds = getFlag("--max-daily-stake");
+          const mer = getFlag("--min-eth-reserve");
+          const art = getFlag("--auto-restake-threshold");
+          const gov = getFlag("--governance-auto-vote");
+          if (mst) b.maxStakePerTx = parseFloat(mst);
+          if (mds) b.maxDailyStake = parseFloat(mds);
+          if (mer) b.minEthReserve = parseFloat(mer);
+          if (art) b.autoRestakeThreshold = parseFloat(art);
+          if (gov) b.governanceAutoVote = gov === "true";
+          saveBounds(b);
+          console.log("Bounds updated:", JSON.stringify(b, null, 2));
+          break;
+        }
+        case "reset": {
+          const { resetBounds } = await import("./store-5CEITPDY.js");
+          resetBounds();
+          console.log("Bounds reset to defaults.");
+          break;
+        }
+        default:
+          console.log("Usage: moly bounds [show|set|reset]");
+          console.log("  set flags: --max-stake-per-tx, --max-daily-stake, --min-eth-reserve, --auto-restake-threshold, --governance-auto-vote");
+      }
+      break;
+    }
+    // ── moly ledger ──────────────────────────────────────────────────
+    case "ledger": {
+      const sub = args[1];
+      const getFlag = (flag) => {
+        const i = args.indexOf(flag);
+        return i !== -1 ? args[i + 1] : void 0;
+      };
+      const { initLedger, queryLedger, ledgerStats, exportLedger } = await import("./store-WRLUM7OW.js");
+      initLedger();
+      switch (sub) {
+        case "list": {
+          const tool = getFlag("--tool");
+          const since = getFlag("--since");
+          const limit = getFlag("--limit");
+          const rows = queryLedger({ tool: tool ?? void 0, since: since ?? void 0, limit: limit ? parseInt(limit) : 50 });
+          console.log(JSON.stringify(rows, null, 2));
+          break;
+        }
+        case "stats": {
+          const since = getFlag("--since");
+          console.log(JSON.stringify(ledgerStats(since ?? void 0), null, 2));
+          break;
+        }
+        case "export": {
+          const format = getFlag("--format") ?? "json";
+          console.log(exportLedger(format));
+          break;
+        }
+        default:
+          console.log("Usage: moly ledger <list|stats|export>");
+          console.log("  list: --tool <name> --since <ISO date> --limit <n>");
+          console.log("  export: --format <json|csv>");
+      }
+      break;
+    }
+    // ── moly position ────────────────────────────────────────────────
+    case "position": {
+      if (!configExists()) {
+        console.log("No config. Run: moly setup");
+        process.exit(1);
+      }
+      const { getTotalPosition } = await import("./position-LKVHTEKX.js");
+      const address = args[1];
+      const pos = await getTotalPosition(address);
+      console.log(JSON.stringify(pos, null, 2));
       break;
     }
     // ── moly --server (force-start, used in AI client configs) ────────
     case "--server": {
       if (!configExists()) {
         process.stderr.write(
-          "ERROR: No config found. Run: npx @moly/lido  to set up first.\n"
+          "ERROR: No config found. Run: npx @moly-mcp/lido  to set up first.\n"
         );
         process.exit(1);
       }
@@ -251,7 +514,7 @@ async function main() {
       if (!configExists()) {
         const { cfg, terminalMode } = await runWizard();
         if (terminalMode) {
-          const { startChatSession } = await import("./session-RFQTJ6WZ.js");
+          const { startChatSession } = await import("./session-37TYTCEU.js");
           await startChatSession(cfg);
         } else {
           await startServer();
@@ -259,7 +522,7 @@ async function main() {
       } else {
         const cfg = loadConfig();
         process.stderr.write(
-          `@moly/lido \u2014 starting MCP server (${cfg.mode} \xB7 ${cfg.network})
+          `@moly-mcp/lido \u2014 starting MCP server (${cfg.mode} \xB7 ${cfg.network})
 `
         );
         await startServer();

package/dist/chunk-6F64RPQQ.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import {
+  loadConfig,
+  updateConfig
+} from "./chunk-P6VFMSPM.js";
+
+// src/alerts/store.ts
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var ALERTS_PATH = join(homedir(), ".moly", "alerts.json");
+function loadAlerts() {
+  if (!existsSync(ALERTS_PATH)) return { alerts: [] };
+  try {
+    return JSON.parse(readFileSync(ALERTS_PATH, "utf-8"));
+  } catch {
+    return { alerts: [] };
+  }
+}
+function saveAlerts(data) {
+  writeFileSync(ALERTS_PATH, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    chmodSync(ALERTS_PATH, 384);
+  } catch {
+  }
+}
+function addAlert(params) {
+  const data = loadAlerts();
+  const alert = {
+    id: randomUUID(),
+    condition: params.condition,
+    threshold: params.threshold,
+    channel: params.channel ?? "telegram",
+    enabled: true,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  data.alerts.push(alert);
+  saveAlerts(data);
+  return alert;
+}
+function removeAlert(id) {
+  const data = loadAlerts();
+  const before = data.alerts.length;
+  data.alerts = data.alerts.filter((a) => a.id !== id);
+  if (data.alerts.length === before) return false;
+  saveAlerts(data);
+  return true;
+}
+function loadChannelConfig() {
+  const cfg = loadConfig();
+  return cfg.alertChannels ?? {};
+}
+function saveChannelConfig(channels) {
+  updateConfig({ alertChannels: channels });
+}
+
+export {
+  loadAlerts,
+  saveAlerts,
+  addAlert,
+  removeAlert,
+  loadChannelConfig,
+  saveChannelConfig
+};

package/dist/chunk-6UIRFWG4.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  addAlert,
+  loadAlerts,
+  loadChannelConfig,
+  removeAlert,
+  saveChannelConfig
+} from "./chunk-6F64RPQQ.js";
+
+// src/tools/alerts.ts
+var VALID_CONDITIONS = [
+  "balance_below",
+  "balance_above",
+  "reward_rate_below",
+  "reward_rate_above",
+  "withdrawal_ready",
+  "proposal_new",
+  "conversion_rate_above",
+  "conversion_rate_below",
+  "reward_delta",
+  "governance_expiring"
+];
+var NEEDS_THRESHOLD = /* @__PURE__ */ new Set([
+  "balance_below",
+  "balance_above",
+  "reward_rate_below",
+  "reward_rate_above",
+  "conversion_rate_above",
+  "conversion_rate_below",
+  "reward_delta"
+]);
+function setAlert(params) {
+  const condition = params.condition;
+  if (!VALID_CONDITIONS.includes(condition)) {
+    throw new Error(`Invalid condition: ${params.condition}. Valid: ${VALID_CONDITIONS.join(", ")}`);
+  }
+  if (NEEDS_THRESHOLD.has(condition) && params.threshold === void 0) {
+    throw new Error(`Condition "${condition}" requires a threshold value`);
+  }
+  const channel = params.channel ?? "telegram";
+  if (channel !== "telegram" && channel !== "webhook") {
+    throw new Error(`Invalid channel: ${params.channel}. Valid: telegram, webhook`);
+  }
+  return addAlert({ condition, threshold: params.threshold, channel });
+}
+function listAlerts() {
+  return loadAlerts();
+}
+function removeAlertById(id) {
+  const removed = removeAlert(id);
+  return { removed, id };
+}
+function configureAlertChannels(params) {
+  const current = loadChannelConfig();
+  if (params.telegram_token && params.telegram_chat_id) {
+    current.telegram = { token: params.telegram_token, chatId: params.telegram_chat_id };
+  }
+  if (params.webhook_url) {
+    current.webhook = { url: params.webhook_url };
+  }
+  saveChannelConfig(current);
+  return {
+    telegram: current.telegram ? { chatId: current.telegram.chatId, token: "*** configured" } : void 0,
+    webhook: current.webhook ? { url: current.webhook.url } : void 0
+  };
+}
+
+export {
+  setAlert,
+  listAlerts,
+  removeAlertById,
+  configureAlertChannels
+};

package/dist/chunk-CH4MXPWS.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/bounds/store.ts
+import { existsSync, readFileSync, writeFileSync, unlinkSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var BOUNDS_PATH = join(homedir(), ".moly", "bounds.json");
+var DEFAULT_BOUNDS = {
+  maxStakePerTx: 10,
+  maxDailyStake: 50,
+  minEthReserve: 0.5,
+  autoRestakeThreshold: 0.05,
+  governanceAutoVote: false,
+  dailyStaked: 0,
+  lastResetDate: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+};
+function loadBounds() {
+  if (!existsSync(BOUNDS_PATH)) return { ...DEFAULT_BOUNDS };
+  try {
+    return { ...DEFAULT_BOUNDS, ...JSON.parse(readFileSync(BOUNDS_PATH, "utf-8")) };
+  } catch {
+    return { ...DEFAULT_BOUNDS };
+  }
+}
+function saveBounds(b) {
+  writeFileSync(BOUNDS_PATH, JSON.stringify(b, null, 2), "utf-8");
+  try {
+    chmodSync(BOUNDS_PATH, 384);
+  } catch {
+  }
+}
+function resetBounds() {
+  if (existsSync(BOUNDS_PATH)) unlinkSync(BOUNDS_PATH);
+}
+
+export {
+  DEFAULT_BOUNDS,
+  loadBounds,
+  saveBounds,
+  resetBounds
+};

package/dist/chunk-CQ6ZSCMZ.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import {
+  applySettingsUpdate,
+  getRuntime
+} from "./chunk-EKZFGIVK.js";
+import {
+  loadConfig,
+  redactedConfig
+} from "./chunk-P6VFMSPM.js";
+
+// src/tools/stake.ts
+import { parseEther, formatEther } from "viem";
+var SUBMIT_ABI = [
+  {
+    name: "submit",
+    type: "function",
+    inputs: [{ name: "_referral", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "payable"
+  }
+];
+var REFERRAL = "0x0000000000000000000000000000000000000000";
+async function stakeEth(amountEth, dryRun) {
+  const rt = getRuntime();
+  const value = parseEther(amountEth);
+  const account = rt.getAddress();
+  const lidoAddress = rt.chainAddresses.stETH;
+  const shouldDryRun = rt.config.mode === "simulation" ? dryRun !== false : !!dryRun;
+  if (shouldDryRun) {
+    let estimatedGas = "unavailable";
+    try {
+      const gas = await rt.publicClient.estimateContractGas({
+        address: lidoAddress,
+        abi: SUBMIT_ABI,
+        functionName: "submit",
+        args: [REFERRAL],
+        value,
+        account: "0x0000000000000000000000000000000000000001"
+      });
+      estimatedGas = gas.toString();
+    } catch {
+    }
+    return {
+      simulated: true,
+      mode: rt.config.mode,
+      network: rt.chainAddresses.name,
+      action: "stake",
+      amountEth,
+      estimatedGas,
+      expectedStETH: amountEth,
+      note: "stETH rebases daily \u2014 your balance grows automatically after staking."
+    };
+  }
+  const tx = await rt.sdk.stake.stakeEth({
+    value,
+    account: { address: account },
+    callback: () => {
+    }
+  });
+  return {
+    simulated: false,
+    mode: rt.config.mode,
+    network: rt.chainAddresses.name,
+    action: "stake",
+    amountEth,
+    txHash: tx.hash,
+    stethReceived: formatEther(tx.result?.stethReceived ?? 0n),
+    sharesReceived: formatEther(tx.result?.sharesReceived ?? 0n)
+  };
+}
+
+// src/tools/settings.ts
+function getSettings() {
+  const cfg = loadConfig();
+  return {
+    ...redactedConfig(cfg),
+    note: "Use update_settings to change mode, network, or rpc. Private key and API keys can only be changed via: moly setup"
+  };
+}
+function updateSettings(patch) {
+  if (Object.keys(patch).length === 0) {
+    return { error: "No settings provided to update." };
+  }
+  const updated = applySettingsUpdate(patch);
+  return {
+    updated: true,
+    changes: patch,
+    current: redactedConfig(updated),
+    note: "Settings saved and applied. SDK reinitialized with new config."
+  };
+}
+
+export {
+  stakeEth,
+  getSettings,
+  updateSettings
+};