@hypurrquant/defi-cli 0.3.5 → 0.4.1

package/dist/main.js

@@ -2,7 +2,7 @@
 
 // src/main.ts
 import { config } from "dotenv";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -19,693 +19,7 @@ import { encodeFunctionData as encodeFunctionData2, decodeFunctionResult, parseA
 import { readFileSync, readdirSync } from "fs";
 import { resolve } from "path";
 import { fileURLToPath } from "url";
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
-function getLineColFromPtr(string, ptr) {
-  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
-  return [lines.length, lines.pop().length + 1];
-}
-function makeCodeBlock(string, line, column) {
-  let lines = string.split(/\r\n|\n|\r/g);
-  let codeblock = "";
-  let numberLen = (Math.log10(line + 1) | 0) + 1;
-  for (let i = line - 1; i <= line + 1; i++) {
-    let l = lines[i - 1];
-    if (!l)
-      continue;
-    codeblock += i.toString().padEnd(numberLen, " ");
-    codeblock += ":  ";
-    codeblock += l;
-    codeblock += "\n";
-    if (i === line) {
-      codeblock += " ".repeat(numberLen + column + 2);
-      codeblock += "^\n";
-    }
-  }
-  return codeblock;
-}
-var TomlError = class extends Error {
-  line;
-  column;
-  codeblock;
-  constructor(message, options) {
-    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
-    const codeblock = makeCodeBlock(options.toml, line, column);
-    super(`Invalid TOML document: ${message}
-
-${codeblock}`, options);
-    this.line = line;
-    this.column = column;
-    this.codeblock = codeblock;
-  }
-};
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/util.js
-function isEscaped(str, ptr) {
-  let i = 0;
-  while (str[ptr - ++i] === "\\")
-    ;
-  return --i && i % 2;
-}
-function indexOfNewline(str, start = 0, end = str.length) {
-  let idx = str.indexOf("\n", start);
-  if (str[idx - 1] === "\r")
-    idx--;
-  return idx <= end ? idx : -1;
-}
-function skipComment(str, ptr) {
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "\n")
-      return i;
-    if (c === "\r" && str[i + 1] === "\n")
-      return i + 1;
-    if (c < " " && c !== "	" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in comments", {
-        toml: str,
-        ptr
-      });
-    }
-  }
-  return str.length;
-}
-function skipVoid(str, ptr, banNewLines, banComments) {
-  let c;
-  while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
-    ptr++;
-  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
-}
-function skipUntil(str, ptr, sep, end, banNewLines = false) {
-  if (!end) {
-    ptr = indexOfNewline(str, ptr);
-    return ptr < 0 ? str.length : ptr;
-  }
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "#") {
-      i = indexOfNewline(str, i);
-    } else if (c === sep) {
-      return i + 1;
-    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
-      return i;
-    }
-  }
-  throw new TomlError("cannot find end of structure", {
-    toml: str,
-    ptr
-  });
-}
-function getStringEnd(str, seek) {
-  let first = str[seek];
-  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
-  seek += target.length - 1;
-  do
-    seek = str.indexOf(target, ++seek);
-  while (seek > -1 && first !== "'" && isEscaped(str, seek));
-  if (seek > -1) {
-    seek += target.length;
-    if (target.length > 1) {
-      if (str[seek] === first)
-        seek++;
-      if (str[seek] === first)
-        seek++;
-    }
-  }
-  return seek;
-}
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/date.js
-var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
-var TomlDate = class _TomlDate extends Date {
-  #hasDate = false;
-  #hasTime = false;
-  #offset = null;
-  constructor(date) {
-    let hasDate = true;
-    let hasTime = true;
-    let offset = "Z";
-    if (typeof date === "string") {
-      let match = date.match(DATE_TIME_RE);
-      if (match) {
-        if (!match[1]) {
-          hasDate = false;
-          date = `0000-01-01T${date}`;
-        }
-        hasTime = !!match[2];
-        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
-        if (match[2] && +match[2] > 23) {
-          date = "";
-        } else {
-          offset = match[3] || null;
-          date = date.toUpperCase();
-          if (!offset && hasTime)
-            date += "Z";
-        }
-      } else {
-        date = "";
-      }
-    }
-    super(date);
-    if (!isNaN(this.getTime())) {
-      this.#hasDate = hasDate;
-      this.#hasTime = hasTime;
-      this.#offset = offset;
-    }
-  }
-  isDateTime() {
-    return this.#hasDate && this.#hasTime;
-  }
-  isLocal() {
-    return !this.#hasDate || !this.#hasTime || !this.#offset;
-  }
-  isDate() {
-    return this.#hasDate && !this.#hasTime;
-  }
-  isTime() {
-    return this.#hasTime && !this.#hasDate;
-  }
-  isValid() {
-    return this.#hasDate || this.#hasTime;
-  }
-  toISOString() {
-    let iso = super.toISOString();
-    if (this.isDate())
-      return iso.slice(0, 10);
-    if (this.isTime())
-      return iso.slice(11, 23);
-    if (this.#offset === null)
-      return iso.slice(0, -1);
-    if (this.#offset === "Z")
-      return iso;
-    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
-    offset = this.#offset[0] === "-" ? offset : -offset;
-    let offsetDate = new Date(this.getTime() - offset * 6e4);
-    return offsetDate.toISOString().slice(0, -1) + this.#offset;
-  }
-  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
-    let date = new _TomlDate(jsDate);
-    date.#offset = offset;
-    return date;
-  }
-  static wrapAsLocalDateTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalDate(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasTime = false;
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasDate = false;
-    date.#offset = null;
-    return date;
-  }
-};
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/primitive.js
-var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
-var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
-var LEADING_ZERO = /^[+-]?0[0-9_]/;
-var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
-var ESC_MAP = {
-  b: "\b",
-  t: "	",
-  n: "\n",
-  f: "\f",
-  r: "\r",
-  e: "\x1B",
-  '"': '"',
-  "\\": "\\"
-};
-function parseString(str, ptr = 0, endPtr = str.length) {
-  let isLiteral = str[ptr] === "'";
-  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
-  if (isMultiline) {
-    endPtr -= 2;
-    if (str[ptr += 2] === "\r")
-      ptr++;
-    if (str[ptr] === "\n")
-      ptr++;
-  }
-  let tmp = 0;
-  let isEscape;
-  let parsed = "";
-  let sliceStart = ptr;
-  while (ptr < endPtr - 1) {
-    let c = str[ptr++];
-    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
-      if (!isMultiline) {
-        throw new TomlError("newlines are not allowed in strings", {
-          toml: str,
-          ptr: ptr - 1
-        });
-      }
-    } else if (c < " " && c !== "	" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in strings", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    }
-    if (isEscape) {
-      isEscape = false;
-      if (c === "x" || c === "u" || c === "U") {
-        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
-        if (!ESCAPE_REGEX.test(code)) {
-          throw new TomlError("invalid unicode escape", {
-            toml: str,
-            ptr: tmp
-          });
-        }
-        try {
-          parsed += String.fromCodePoint(parseInt(code, 16));
-        } catch {
-          throw new TomlError("invalid unicode escape", {
-            toml: str,
-            ptr: tmp
-          });
-        }
-      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
-        ptr = skipVoid(str, ptr - 1, true);
-        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
-          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
-            toml: str,
-            ptr: tmp
-          });
-        }
-        ptr = skipVoid(str, ptr);
-      } else if (c in ESC_MAP) {
-        parsed += ESC_MAP[c];
-      } else {
-        throw new TomlError("unrecognized escape sequence", {
-          toml: str,
-          ptr: tmp
-        });
-      }
-      sliceStart = ptr;
-    } else if (!isLiteral && c === "\\") {
-      tmp = ptr - 1;
-      isEscape = true;
-      parsed += str.slice(sliceStart, tmp);
-    }
-  }
-  return parsed + str.slice(sliceStart, endPtr - 1);
-}
-function parseValue(value, toml, ptr, integersAsBigInt) {
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  if (value === "-inf")
-    return -Infinity;
-  if (value === "inf" || value === "+inf")
-    return Infinity;
-  if (value === "nan" || value === "+nan" || value === "-nan")
-    return NaN;
-  if (value === "-0")
-    return integersAsBigInt ? 0n : 0;
-  let isInt = INT_REGEX.test(value);
-  if (isInt || FLOAT_REGEX.test(value)) {
-    if (LEADING_ZERO.test(value)) {
-      throw new TomlError("leading zeroes are not allowed", {
-        toml,
-        ptr
-      });
-    }
-    value = value.replace(/_/g, "");
-    let numeric = +value;
-    if (isNaN(numeric)) {
-      throw new TomlError("invalid number", {
-        toml,
-        ptr
-      });
-    }
-    if (isInt) {
-      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
-        throw new TomlError("integer value cannot be represented losslessly", {
-          toml,
-          ptr
-        });
-      }
-      if (isInt || integersAsBigInt === true)
-        numeric = BigInt(value);
-    }
-    return numeric;
-  }
-  const date = new TomlDate(value);
-  if (!date.isValid()) {
-    throw new TomlError("invalid value", {
-      toml,
-      ptr
-    });
-  }
-  return date;
-}
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/extract.js
-function sliceAndTrimEndOf(str, startPtr, endPtr) {
-  let value = str.slice(startPtr, endPtr);
-  let commentIdx = value.indexOf("#");
-  if (commentIdx > -1) {
-    skipComment(str, commentIdx);
-    value = value.slice(0, commentIdx);
-  }
-  return [value.trimEnd(), commentIdx];
-}
-function extractValue(str, ptr, end, depth, integersAsBigInt) {
-  if (depth === 0) {
-    throw new TomlError("document contains excessively nested structures. aborting.", {
-      toml: str,
-      ptr
-    });
-  }
-  let c = str[ptr];
-  if (c === "[" || c === "{") {
-    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
-    if (end) {
-      endPtr2 = skipVoid(str, endPtr2);
-      if (str[endPtr2] === ",")
-        endPtr2++;
-      else if (str[endPtr2] !== end) {
-        throw new TomlError("expected comma or end of structure", {
-          toml: str,
-          ptr: endPtr2
-        });
-      }
-    }
-    return [value, endPtr2];
-  }
-  let endPtr;
-  if (c === '"' || c === "'") {
-    endPtr = getStringEnd(str, ptr);
-    let parsed = parseString(str, ptr, endPtr);
-    if (end) {
-      endPtr = skipVoid(str, endPtr);
-      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
-        throw new TomlError("unexpected character encountered", {
-          toml: str,
-          ptr: endPtr
-        });
-      }
-      endPtr += +(str[endPtr] === ",");
-    }
-    return [parsed, endPtr];
-  }
-  endPtr = skipUntil(str, ptr, ",", end);
-  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
-  if (!slice[0]) {
-    throw new TomlError("incomplete key-value declaration: no value specified", {
-      toml: str,
-      ptr
-    });
-  }
-  if (end && slice[1] > -1) {
-    endPtr = skipVoid(str, ptr + slice[1]);
-    endPtr += +(str[endPtr] === ",");
-  }
-  return [
-    parseValue(slice[0], str, ptr, integersAsBigInt),
-    endPtr
-  ];
-}
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/struct.js
-var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-function parseKey(str, ptr, end = "=") {
-  let dot = ptr - 1;
-  let parsed = [];
-  let endPtr = str.indexOf(end, ptr);
-  if (endPtr < 0) {
-    throw new TomlError("incomplete key-value: cannot find end of key", {
-      toml: str,
-      ptr
-    });
-  }
-  do {
-    let c = str[ptr = ++dot];
-    if (c !== " " && c !== "	") {
-      if (c === '"' || c === "'") {
-        if (c === str[ptr + 1] && c === str[ptr + 2]) {
-          throw new TomlError("multiline strings are not allowed in keys", {
-            toml: str,
-            ptr
-          });
-        }
-        let eos = getStringEnd(str, ptr);
-        if (eos < 0) {
-          throw new TomlError("unfinished string encountered", {
-            toml: str,
-            ptr
-          });
-        }
-        dot = str.indexOf(".", eos);
-        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
-        let newLine = indexOfNewline(strEnd);
-        if (newLine > -1) {
-          throw new TomlError("newlines are not allowed in keys", {
-            toml: str,
-            ptr: ptr + dot + newLine
-          });
-        }
-        if (strEnd.trimStart()) {
-          throw new TomlError("found extra tokens after the string part", {
-            toml: str,
-            ptr: eos
-          });
-        }
-        if (endPtr < eos) {
-          endPtr = str.indexOf(end, eos);
-          if (endPtr < 0) {
-            throw new TomlError("incomplete key-value: cannot find end of key", {
-              toml: str,
-              ptr
-            });
-          }
-        }
-        parsed.push(parseString(str, ptr, eos));
-      } else {
-        dot = str.indexOf(".", ptr);
-        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
-        if (!KEY_PART_RE.test(part)) {
-          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
-            toml: str,
-            ptr
-          });
-        }
-        parsed.push(part.trimEnd());
-      }
-    }
-  } while (dot + 1 && dot < endPtr);
-  return [parsed, skipVoid(str, endPtr + 1, true, true)];
-}
-function parseInlineTable(str, ptr, depth, integersAsBigInt) {
-  let res = {};
-  let seen = /* @__PURE__ */ new Set();
-  let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "}" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let k;
-      let t = res;
-      let hasOwn = false;
-      let [key, keyEndPtr] = parseKey(str, ptr - 1);
-      for (let i = 0; i < key.length; i++) {
-        if (i)
-          t = hasOwn ? t[k] : t[k] = {};
-        k = key[i];
-        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
-          throw new TomlError("trying to redefine an already defined value", {
-            toml: str,
-            ptr
-          });
-        }
-        if (!hasOwn && k === "__proto__") {
-          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
-        }
-      }
-      if (hasOwn) {
-        throw new TomlError("trying to redefine an already defined value", {
-          toml: str,
-          ptr
-        });
-      }
-      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
-      seen.add(value);
-      t[k] = value;
-      ptr = valueEndPtr;
-    }
-  }
-  if (!c) {
-    throw new TomlError("unfinished table encountered", {
-      toml: str,
-      ptr
-    });
-  }
-  return [res, ptr];
-}
-function parseArray(str, ptr, depth, integersAsBigInt) {
-  let res = [];
-  let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "]" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
-      res.push(e[0]);
-      ptr = e[1];
-    }
-  }
-  if (!c) {
-    throw new TomlError("unfinished array encountered", {
-      toml: str,
-      ptr
-    });
-  }
-  return [res, ptr];
-}
-
-// ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/parse.js
-function peekTable(key, table, meta, type) {
-  let t = table;
-  let m = meta;
-  let k;
-  let hasOwn = false;
-  let state;
-  for (let i = 0; i < key.length; i++) {
-    if (i) {
-      t = hasOwn ? t[k] : t[k] = {};
-      m = (state = m[k]).c;
-      if (type === 0 && (state.t === 1 || state.t === 2)) {
-        return null;
-      }
-      if (state.t === 2) {
-        let l = t.length - 1;
-        t = t[l];
-        m = m[l].c;
-      }
-    }
-    k = key[i];
-    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
-      return null;
-    }
-    if (!hasOwn) {
-      if (k === "__proto__") {
-        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
-        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
-      }
-      m[k] = {
-        t: i < key.length - 1 && type === 2 ? 3 : type,
-        d: false,
-        i: 0,
-        c: {}
-      };
-    }
-  }
-  state = m[k];
-  if (state.t !== type && !(type === 1 && state.t === 3)) {
-    return null;
-  }
-  if (type === 2) {
-    if (!state.d) {
-      state.d = true;
-      t[k] = [];
-    }
-    t[k].push(t = {});
-    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
-  }
-  if (state.d) {
-    return null;
-  }
-  state.d = true;
-  if (type === 1) {
-    t = hasOwn ? t[k] : t[k] = {};
-  } else if (type === 0 && hasOwn) {
-    return null;
-  }
-  return [k, t, state.c];
-}
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
-  let res = {};
-  let meta = {};
-  let tbl = res;
-  let m = meta;
-  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
-    if (toml[ptr] === "[") {
-      let isTableArray = toml[++ptr] === "[";
-      let k = parseKey(toml, ptr += +isTableArray, "]");
-      if (isTableArray) {
-        if (toml[k[1] - 1] !== "]") {
-          throw new TomlError("expected end of table declaration", {
-            toml,
-            ptr: k[1] - 1
-          });
-        }
-        k[1]++;
-      }
-      let p = peekTable(
-        k[0],
-        res,
-        meta,
-        isTableArray ? 2 : 1
-        /* Type.EXPLICIT */
-      );
-      if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr
-        });
-      }
-      m = p[2];
-      tbl = p[1];
-      ptr = k[1];
-    } else {
-      let k = parseKey(toml, ptr);
-      let p = peekTable(
-        k[0],
-        tbl,
-        m,
-        0
-        /* Type.DOTTED */
-      );
-      if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr
-        });
-      }
-      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
-      p[1][p[0]] = v[0];
-      ptr = v[1];
-    }
-    ptr = skipVoid(toml, ptr, true);
-    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
-      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
-        toml,
-        ptr
-      });
-    }
-    ptr = skipVoid(toml, ptr);
-  }
-  return res;
-}
-
-// ../defi-core/dist/index.js
+import { parse } from "smol-toml";
 import { existsSync } from "fs";
 var TxStatus = /* @__PURE__ */ ((TxStatus2) => {
   TxStatus2["DryRun"] = "dry_run";
@@ -1698,8 +1012,25 @@ function isPlaceholder(addr) {
 function registerStatus(parent, getOpts) {
   parent.command("status").description("Show chain and protocol status").option("--verify", "Verify contract addresses on-chain").action(async (opts) => {
     const globalOpts = parent.opts();
-    const chainName = globalOpts.chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chainKeys = globalOpts.chain ? [globalOpts.chain] : Array.from(registry.chains.keys());
+    if (chainKeys.length > 1) {
+      const summary = [];
+      for (const ck of chainKeys) {
+        const cc = registry.getChain(ck);
+        const protos = registry.getProtocolsForChain(ck);
+        summary.push({
+          chain: cc.name,
+          chain_id: cc.chain_id,
+          rpc_url: cc.effectiveRpcUrl(),
+          protocols: protos.map((p) => ({ slug: p.slug, name: p.name, category: p.category, interface: p.interface })),
+          summary: { total_protocols: protos.length }
+        });
+      }
+      printOutput(summary, getOpts());
+      return;
+    }
+    const chainName = chainKeys[0];
     const chainConfig = registry.getChain(chainName);
     const chainProtocols = registry.getProtocolsForChain(chainName);
     let blockNumber;
@@ -1803,27 +1134,34 @@ function registerStatus(parent, getOpts) {
 function handleSchema(params) {
   const action = typeof params["action"] === "string" ? params["action"] : "all";
   switch (action) {
-    case "dex.swap":
+    case "status":
+      return { action: "status", params: {}, cli: "defi status" };
+    case "list_protocols":
+      return {
+        action: "list_protocols",
+        params: {
+          category: { type: "string", required: false, description: "Filter by category (e.g. dex, lending)" }
+        },
+        cli: "defi status"
+      };
+    case "yield":
       return {
-        action: "dex.swap",
+        action: "yield",
         params: {
-          protocol: { type: "string", required: true, description: "Protocol slug (e.g. hyperswap-v3)" },
-          token_in: { type: "string", required: true, description: "Input token symbol or address" },
-          token_out: { type: "string", required: true, description: "Output token symbol or address" },
-          amount: { type: "string", required: true, description: "Amount (human-readable, e.g. '1.5')" },
-          slippage_bps: { type: "number", required: false, default: 50, description: "Slippage in basis points" },
-          recipient: { type: "string", required: false, description: "Recipient address" }
-        }
+          chain: { type: "string", required: false, description: "Target chain (omit for all chains)" },
+          asset: { type: "string", required: false, default: "USDC", description: "Token symbol" }
+        },
+        cli: "defi yield --asset USDC"
       };
-    case "dex.quote":
+    case "lending.rates":
       return {
-        action: "dex.quote",
+        action: "lending.rates",
         params: {
+          chain: { type: "string", required: true, description: "Target chain" },
           protocol: { type: "string", required: true, description: "Protocol slug" },
-          token_in: { type: "string", required: true, description: "Input token symbol or address" },
-          token_out: { type: "string", required: true, description: "Output token symbol or address" },
-          amount: { type: "string", required: true, description: "Amount (human-readable)" }
-        }
+          asset: { type: "string", required: true, description: "Token symbol or address" }
+        },
+        cli: "defi --chain hyperevm lending rates --protocol hypurrfi --asset USDC"
       };
     case "lending.supply":
     case "lending.borrow":
@@ -1832,47 +1170,54 @@ function handleSchema(params) {
       return {
         action,
         params: {
+          chain: { type: "string", required: true, description: "Target chain" },
           protocol: { type: "string", required: true, description: "Protocol slug" },
           asset: { type: "string", required: true, description: "Token symbol or address" },
-          amount: { type: "string", required: true, description: "Amount (human-readable)" }
-        }
+          amount: { type: "string", required: true, description: "Amount in wei" }
+        },
+        cli: `defi --chain hyperevm lending ${action.split(".")[1]} --protocol hypurrfi --asset USDC --amount 1000000`
       };
-    case "staking.stake":
-    case "staking.unstake":
+    case "lp.discover":
       return {
-        action,
+        action: "lp.discover",
         params: {
-          protocol: { type: "string", required: true, description: "Protocol slug" },
-          amount: { type: "string", required: true, description: "Amount (human-readable)" }
-        }
+          chain: { type: "string", required: true, description: "Target chain" },
+          protocol: { type: "string", required: false, description: "Filter by protocol slug" }
+        },
+        cli: "defi --chain hyperevm lp discover"
       };
-    case "vault.deposit":
-    case "vault.withdraw":
+    case "swap":
       return {
-        action,
+        action: "swap",
         params: {
-          protocol: { type: "string", required: true, description: "Protocol slug" },
-          amount: { type: "string", required: true, description: "Amount (human-readable)" }
-        }
+          chain: { type: "string", required: true, description: "Target chain" },
+          from: { type: "string", required: true, description: "Input token symbol or address" },
+          to: { type: "string", required: true, description: "Output token symbol or address" },
+          amount: { type: "string", required: true, description: "Amount in wei" },
+          provider: { type: "string", required: false, default: "kyber", description: "Aggregator: kyber, openocean, liquid" },
+          slippage: { type: "string", required: false, default: "50", description: "Slippage in bps" }
+        },
+        cli: "defi --chain hyperevm swap --from USDC --to WHYPE --amount 1000000"
       };
-    case "cdp.open":
+    case "price":
       return {
-        action: "cdp.open",
+        action: "price",
         params: {
-          protocol: { type: "string", required: true, description: "Protocol slug" },
-          collateral: { type: "string", required: true, description: "Collateral token symbol or address" },
-          collateral_amount: { type: "string", required: true, description: "Collateral amount (human-readable)" },
-          debt_amount: { type: "string", required: true, description: "Debt amount (human-readable)" }
-        }
+          chain: { type: "string", required: true, description: "Target chain" },
+          asset: { type: "string", required: true, description: "Token symbol or address" }
+        },
+        cli: "defi --chain hyperevm price --asset WHYPE"
       };
-    case "status":
-      return { action: "status", params: {} };
-    case "list_protocols":
+    case "bridge":
       return {
-        action: "list_protocols",
+        action: "bridge",
         params: {
-          category: { type: "string", required: false, description: "Filter by category (e.g. dex, lending, vault)" }
-        }
+          chain: { type: "string", required: true, description: "Source chain" },
+          token: { type: "string", required: true, description: "Token symbol or address" },
+          amount: { type: "string", required: true, description: "Amount in wei" },
+          to_chain: { type: "string", required: true, description: "Destination chain" }
+        },
+        cli: "defi --chain hyperevm bridge --token USDC --amount 1000000 --to-chain mantle"
       };
     default:
       return {
@@ -1880,17 +1225,25 @@ function handleSchema(params) {
           "status",
           "list_protocols",
           "schema",
-          "dex.swap",
-          "dex.quote",
+          "yield",
+          "lending.rates",
           "lending.supply",
           "lending.borrow",
           "lending.repay",
           "lending.withdraw",
-          "staking.stake",
-          "staking.unstake",
-          "vault.deposit",
-          "vault.withdraw",
-          "cdp.open"
+          "lp.discover",
+          "lp.add",
+          "lp.farm",
+          "lp.claim",
+          "lp.remove",
+          "swap",
+          "price",
+          "token.balance",
+          "token.approve",
+          "token.transfer",
+          "wallet.balance",
+          "portfolio.show",
+          "bridge"
         ]
       };
   }
@@ -4145,7 +3498,8 @@ var lbQuoterAbi2 = parseAbi12([
   "function findBestPathFromAmountIn(address[] calldata route, uint128 amountIn) external view returns ((address[] route, address[] pairs, uint256[] binSteps, uint256[] versions, uint128[] amounts, uint128[] virtualAmountsWithoutSlippage, uint128[] fees))"
 ]);
 var erc20Abi2 = parseAbi12([
-  "function symbol() external view returns (string)"
+  "function symbol() external view returns (string)",
+  "function balanceOf(address account) external view returns (uint256)"
 ]);
 var _addressAbi = parseAbi12(["function f() external view returns (address)"]);
 function decodeAddressResult(data) {
@@ -4653,6 +4007,74 @@ var MerchantMoeLBAdapter = class {
       } catch {
       }
     }
+    const stableSymbols = /* @__PURE__ */ new Set(["USDT", "USDC", "USDT0", "MUSD", "AUSD", "USDY", "FDUSD", "USDe", "sUSDe"]);
+    const mntSymbols = /* @__PURE__ */ new Set(["WMNT", "MNT"]);
+    const moeSymbols = /* @__PURE__ */ new Set(["MOE"]);
+    const sixDecimalStables = /* @__PURE__ */ new Set(["USDT", "USDC", "USDT0", "FDUSD"]);
+    const tokenPriceMap = /* @__PURE__ */ new Map();
+    const tokenDecimalsMap = /* @__PURE__ */ new Map();
+    for (const [addr, sym] of symbolMap) {
+      const key = addr.toLowerCase();
+      if (stableSymbols.has(sym)) {
+        tokenPriceMap.set(key, 1);
+        tokenDecimalsMap.set(key, sixDecimalStables.has(sym) ? 6 : 18);
+      } else if (mntSymbols.has(sym)) {
+        tokenPriceMap.set(key, wmntPriceUsd);
+        tokenDecimalsMap.set(key, 18);
+      } else if (moeSymbols.has(sym)) {
+        tokenPriceMap.set(key, moePriceUsd);
+        tokenDecimalsMap.set(key, 18);
+      }
+    }
+    const unknownTokenAddrs = [];
+    for (let i = 0; i < rewardedPairs.length; i++) {
+      for (const addr of [tokenXAddresses[i], tokenYAddresses[i]]) {
+        if (addr && !tokenPriceMap.has(addr.toLowerCase())) {
+          if (!unknownTokenAddrs.some((a) => a.toLowerCase() === addr.toLowerCase())) {
+            unknownTokenAddrs.push(addr);
+          }
+        }
+      }
+    }
+    if (unknownTokenAddrs.length > 0 && this.lbQuoter && this.wmnt && wmntPriceUsd > 0) {
+      const erc20DecimalsAbi = parseAbi12(["function decimals() external view returns (uint8)"]);
+      const decCalls = unknownTokenAddrs.map((addr) => [
+        addr,
+        encodeFunctionData12({ abi: erc20DecimalsAbi, functionName: "decimals" })
+      ]);
+      const decResults = await multicallRead(rpcUrl, decCalls).catch(() => []);
+      for (let i = 0; i < unknownTokenAddrs.length; i++) {
+        const dec = decResults[i] ? Number(decodeUint256Result(decResults[i]) ?? 18n) : 18;
+        tokenDecimalsMap.set(unknownTokenAddrs[i].toLowerCase(), dec);
+      }
+      const quotePromises = unknownTokenAddrs.map(async (tokenAddr) => {
+        try {
+          const dec = tokenDecimalsMap.get(tokenAddr.toLowerCase()) ?? 18;
+          const quoteUnit = 10n ** BigInt(Math.max(dec - 2, 0));
+          const quote = await client.readContract({
+            address: this.lbQuoter,
+            abi: lbQuoterAbi2,
+            functionName: "findBestPathFromAmountIn",
+            args: [[tokenAddr, this.wmnt], quoteUnit]
+          });
+          const amountOut = quote.amounts?.at(-1) ?? 0n;
+          const priceInWmnt = Number(amountOut) / 1e18 * (10 ** dec / Number(quoteUnit));
+          return { addr: tokenAddr, price: priceInWmnt * wmntPriceUsd };
+        } catch {
+          return { addr: tokenAddr, price: 0 };
+        }
+      });
+      const priceResults = await Promise.all(quotePromises);
+      for (const { addr, price } of priceResults) {
+        if (price > 0) tokenPriceMap.set(addr.toLowerCase(), price);
+      }
+    }
+    const getTokenPriceUsd = (_sym, addr) => {
+      return tokenPriceMap.get(addr.toLowerCase()) ?? 0;
+    };
+    const getTokenDecimals = (_sym, addr) => {
+      return tokenDecimalsMap.get(addr.toLowerCase()) ?? 18;
+    };
     const binRequests = [];
     for (let i = 0; i < rewardedPairs.length; i++) {
       const range = poolData[i].range;
@@ -4683,19 +4105,23 @@ var MerchantMoeLBAdapter = class {
         binReservesY.get(poolIdx).set(binId, decoded[1]);
       }
     }
-    const stableSymbols = /* @__PURE__ */ new Set(["USDT", "USDC", "MUSD", "AUSD", "USDY", "FDUSD"]);
-    const mntSymbols = /* @__PURE__ */ new Set(["WMNT", "MNT"]);
-    const moeSymbols = /* @__PURE__ */ new Set(["MOE"]);
-    const sixDecimalStables = /* @__PURE__ */ new Set(["USDT", "USDC", "FDUSD"]);
-    const getTokenPriceUsd = (sym) => {
-      if (stableSymbols.has(sym)) return 1;
-      if (mntSymbols.has(sym)) return wmntPriceUsd;
-      if (moeSymbols.has(sym)) return moePriceUsd;
-      return 0;
-    };
-    const getTokenDecimals = (sym) => {
-      return sixDecimalStables.has(sym) ? 6 : 18;
-    };
+    const poolBalanceX = /* @__PURE__ */ new Map();
+    const poolBalanceY = /* @__PURE__ */ new Map();
+    {
+      const balCalls = [];
+      for (let i = 0; i < rewardedPairs.length; i++) {
+        const tx = tokenXAddresses[i];
+        const ty = tokenYAddresses[i];
+        const pool = rewardedPairs[i].pool;
+        balCalls.push([tx ?? "0x0000000000000000000000000000000000000000", encodeFunctionData12({ abi: erc20Abi2, functionName: "balanceOf", args: [pool] })]);
+        balCalls.push([ty ?? "0x0000000000000000000000000000000000000000", encodeFunctionData12({ abi: erc20Abi2, functionName: "balanceOf", args: [pool] })]);
+      }
+      const balResults = await multicallRead(rpcUrl, balCalls).catch(() => []);
+      for (let i = 0; i < rewardedPairs.length; i++) {
+        poolBalanceX.set(i, decodeUint256Result(balResults[i * 2] ?? null) ?? 0n);
+        poolBalanceY.set(i, decodeUint256Result(balResults[i * 2 + 1] ?? null) ?? 0n);
+      }
+    }
     const results = [];
     for (let i = 0; i < rewardedPairs.length; i++) {
       const { pool, rewarder } = rewardedPairs[i];
@@ -4720,18 +4146,25 @@ var MerchantMoeLBAdapter = class {
         const maxBin = Number(range[1]);
         rewardedBins = maxBin - minBin + 1;
         if (rxMap && ryMap) {
-          const priceX = getTokenPriceUsd(symX);
-          const priceY = getTokenPriceUsd(symY);
-          const decX = getTokenDecimals(symX);
-          const decY = getTokenDecimals(symY);
+          const priceX2 = getTokenPriceUsd(symX, tokenX);
+          const priceY2 = getTokenPriceUsd(symY, tokenY);
+          const decX2 = getTokenDecimals(symX, tokenX);
+          const decY2 = getTokenDecimals(symY, tokenY);
           for (let b = minBin; b <= maxBin; b++) {
             const rx = rxMap.get(b) ?? 0n;
             const ry = ryMap.get(b) ?? 0n;
-            rangeTvlUsd += Number(rx) / 10 ** decX * priceX;
-            rangeTvlUsd += Number(ry) / 10 ** decY * priceY;
+            rangeTvlUsd += Number(rx) / 10 ** decX2 * priceX2;
+            rangeTvlUsd += Number(ry) / 10 ** decY2 * priceY2;
           }
         }
       }
+      const priceX = getTokenPriceUsd(symX, tokenX);
+      const priceY = getTokenPriceUsd(symY, tokenY);
+      const decX = getTokenDecimals(symX, tokenX);
+      const decY = getTokenDecimals(symY, tokenY);
+      const fullBalX = poolBalanceX.get(i) ?? 0n;
+      const fullBalY = poolBalanceY.get(i) ?? 0n;
+      const poolTvlUsd = Number(fullBalX) / 10 ** decX * priceX + Number(fullBalY) / 10 ** decY * priceY;
       const aprPercent = rangeTvlUsd > 0 && moePriceUsd > 0 ? poolMoePerDay * moePriceUsd * 365 / rangeTvlUsd * 100 : 0;
       results.push({
         pool,
@@ -4748,8 +4181,11 @@ var MerchantMoeLBAdapter = class {
         isTopPool,
         moePerDay: poolMoePerDay,
         rangeTvlUsd,
+        poolTvlUsd,
         aprPercent,
-        rewardedBins
+        rewardedBins,
+        totalMoePerDay: moePerDay,
+        moePriceUsd
       });
     }
     return results;
@@ -6392,201 +5828,52 @@ var HINT_HELPERS_ABI = parseAbi21([
 var SORTED_TROVES_ABI = parseAbi21([
   "function findInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (uint256 prevId, uint256 nextId)"
 ]);
-var FelixCdpAdapter = class {
+var PRICE_FEED_ABI = parseAbi222([
+  "function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected)",
+  "function lastGoodPrice() external view returns (uint256)"
+]);
+var FelixOracleAdapter = class {
   protocolName;
-  borrowerOperations;
-  troveManager;
-  hintHelpers;
-  sortedTroves;
+  priceFeed;
+  asset;
   rpcUrl;
   constructor(entry, rpcUrl) {
     this.protocolName = entry.name;
+    if (!rpcUrl) throw DefiError.rpcError(`[${entry.name}] RPC URL required for oracle`);
     this.rpcUrl = rpcUrl;
     const contracts = entry.contracts ?? {};
-    const bo = contracts["borrower_operations"];
-    if (!bo) throw DefiError.contractError("Missing 'borrower_operations' contract");
-    this.borrowerOperations = bo;
-    this.troveManager = contracts["trove_manager"];
-    this.hintHelpers = contracts["hint_helpers"];
-    this.sortedTroves = contracts["sorted_troves"];
+    const feed = contracts["price_feed"];
+    if (!feed) throw DefiError.contractError(`[${entry.name}] Missing 'price_feed' contract address`);
+    this.priceFeed = feed;
+    this.asset = contracts["asset"] ?? "0x0000000000000000000000000000000000000000";
   }
   name() {
     return this.protocolName;
   }
-  async getHints(interestRate) {
-    if (!this.hintHelpers || !this.sortedTroves || !this.rpcUrl) {
-      return [0n, 0n];
+  async getPrice(asset) {
+    if (asset !== this.asset && this.asset !== "0x0000000000000000000000000000000000000000") {
+      throw DefiError.unsupported(`[${this.protocolName}] Felix PriceFeed only supports asset ${this.asset}`);
     }
-    const client = createPublicClient16({ transport: http16(this.rpcUrl) });
-    const approxResult = await client.readContract({
-      address: this.hintHelpers,
-      abi: HINT_HELPERS_ABI,
-      functionName: "getApproxHint",
-      args: [0n, interestRate, 15n, 42n]
-    }).catch(() => null);
-    if (!approxResult) return [0n, 0n];
-    const [hintId] = approxResult;
-    const insertResult = await client.readContract({
-      address: this.sortedTroves,
-      abi: SORTED_TROVES_ABI,
-      functionName: "findInsertPosition",
-      args: [interestRate, hintId, hintId]
-    }).catch(() => null);
-    if (!insertResult) return [0n, 0n];
-    const [prevId, nextId] = insertResult;
-    return [prevId, nextId];
-  }
-  async buildOpen(params) {
-    const interestRate = 50000000000000000n;
-    const [upperHint, lowerHint] = await this.getHints(interestRate);
-    const hasHints = upperHint !== 0n || lowerHint !== 0n;
-    const data = encodeFunctionData20({
-      abi: BORROWER_OPS_ABI,
-      functionName: "openTrove",
-      args: [
-        params.recipient,
-        0n,
-        params.collateral_amount,
-        params.debt_amount,
-        upperHint,
-        lowerHint,
-        interestRate,
-        BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-        // U256::MAX
-        params.recipient,
-        params.recipient,
-        params.recipient
-      ]
-    });
-    return {
-      description: `[${this.protocolName}] Open trove: collateral=${params.collateral_amount}, debt=${params.debt_amount} (hints=${hasHints ? "optimized" : "none"})`,
-      to: this.borrowerOperations,
-      data,
-      value: 0n,
-      gas_estimate: hasHints ? 5e5 : 5e6
-    };
-  }
-  async buildAdjust(params) {
-    const collChange = params.collateral_delta ?? 0n;
-    const debtChange = params.debt_delta ?? 0n;
-    const data = encodeFunctionData20({
-      abi: BORROWER_OPS_ABI,
-      functionName: "adjustTrove",
-      args: [
-        params.cdp_id,
-        collChange,
-        params.add_collateral,
-        debtChange,
-        params.add_debt,
-        0n,
-        0n,
-        BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
-      ]
-    });
-    return {
-      description: `[${this.protocolName}] Adjust trove ${params.cdp_id}`,
-      to: this.borrowerOperations,
-      data,
-      value: 0n,
-      gas_estimate: 4e5
-    };
-  }
-  async buildClose(params) {
-    const data = encodeFunctionData20({
-      abi: BORROWER_OPS_ABI,
-      functionName: "closeTrove",
-      args: [params.cdp_id]
-    });
-    return {
-      description: `[${this.protocolName}] Close trove ${params.cdp_id}`,
-      to: this.borrowerOperations,
-      data,
-      value: 0n,
-      gas_estimate: 35e4
-    };
-  }
-  async getCdpInfo(cdpId) {
-    if (!this.rpcUrl) throw DefiError.rpcError(`[${this.protocolName}] getCdpInfo requires RPC \u2014 set HYPEREVM_RPC_URL`);
-    if (!this.troveManager) throw DefiError.contractError(`[${this.protocolName}] trove_manager contract not configured`);
-    const client = createPublicClient16({ transport: http16(this.rpcUrl) });
-    const data = await client.readContract({
-      address: this.troveManager,
-      abi: TROVE_MANAGER_ABI,
-      functionName: "getLatestTroveData",
-      args: [cdpId]
-    }).catch((e) => {
-      throw DefiError.invalidParam(`[${this.protocolName}] Trove ${cdpId} not found: ${e}`);
-    });
-    const [entireDebt, entireColl] = data;
-    if (entireDebt === 0n && entireColl === 0n) {
-      throw DefiError.invalidParam(`[${this.protocolName}] Trove ${cdpId} does not exist`);
-    }
-    const collRatio = entireDebt > 0n ? Number(entireColl) / Number(entireDebt) : 0;
-    return {
-      protocol: this.protocolName,
-      cdp_id: cdpId,
-      collateral: {
-        token: zeroAddress11,
-        symbol: "WHYPE",
-        amount: entireColl,
-        decimals: 18
-      },
-      debt: {
-        token: zeroAddress11,
-        symbol: "feUSD",
-        amount: entireDebt,
-        decimals: 18
-      },
-      collateral_ratio: collRatio
-    };
-  }
-};
-var PRICE_FEED_ABI = parseAbi222([
-  "function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected)",
-  "function lastGoodPrice() external view returns (uint256)"
-]);
-var FelixOracleAdapter = class {
-  protocolName;
-  priceFeed;
-  asset;
-  rpcUrl;
-  constructor(entry, rpcUrl) {
-    this.protocolName = entry.name;
-    if (!rpcUrl) throw DefiError.rpcError(`[${entry.name}] RPC URL required for oracle`);
-    this.rpcUrl = rpcUrl;
-    const contracts = entry.contracts ?? {};
-    const feed = contracts["price_feed"];
-    if (!feed) throw DefiError.contractError(`[${entry.name}] Missing 'price_feed' contract address`);
-    this.priceFeed = feed;
-    this.asset = contracts["asset"] ?? "0x0000000000000000000000000000000000000000";
-  }
-  name() {
-    return this.protocolName;
-  }
-  async getPrice(asset) {
-    if (asset !== this.asset && this.asset !== "0x0000000000000000000000000000000000000000") {
-      throw DefiError.unsupported(`[${this.protocolName}] Felix PriceFeed only supports asset ${this.asset}`);
-    }
-    const client = createPublicClient17({ transport: http17(this.rpcUrl) });
-    let priceVal;
-    try {
-      const result = await client.readContract({
-        address: this.priceFeed,
-        abi: PRICE_FEED_ABI,
-        functionName: "fetchPrice"
-      });
-      const [price] = result;
-      priceVal = price;
-    } catch {
-      priceVal = await client.readContract({
-        address: this.priceFeed,
-        abi: PRICE_FEED_ABI,
-        functionName: "lastGoodPrice"
-      }).catch((e) => {
-        throw DefiError.rpcError(`[${this.protocolName}] lastGoodPrice failed: ${e}`);
-      });
-    }
-    const priceF64 = Number(priceVal) / 1e18;
+    const client = createPublicClient17({ transport: http17(this.rpcUrl) });
+    let priceVal;
+    try {
+      const result = await client.readContract({
+        address: this.priceFeed,
+        abi: PRICE_FEED_ABI,
+        functionName: "fetchPrice"
+      });
+      const [price] = result;
+      priceVal = price;
+    } catch {
+      priceVal = await client.readContract({
+        address: this.priceFeed,
+        abi: PRICE_FEED_ABI,
+        functionName: "lastGoodPrice"
+      }).catch((e) => {
+        throw DefiError.rpcError(`[${this.protocolName}] lastGoodPrice failed: ${e}`);
+      });
+    }
+    const priceF64 = Number(priceVal) / 1e18;
     return {
       source: "Felix PriceFeed",
       source_type: "oracle",
@@ -6796,14 +6083,6 @@ function createLending(entry, rpcUrl) {
       throw DefiError.unsupported(`Lending interface '${entry.interface}' not yet implemented`);
   }
 }
-function createCdp(entry, rpcUrl) {
-  switch (entry.interface) {
-    case "liquity_v2":
-      return new FelixCdpAdapter(entry, rpcUrl);
-    default:
-      throw DefiError.unsupported(`CDP interface '${entry.interface}' not yet implemented`);
-  }
-}
 function createVault(entry, rpcUrl) {
   switch (entry.interface) {
     case "erc4626":
@@ -6899,6 +6178,21 @@ var DexSpotPrice = class {
   }
 };
 
+// src/whitelist.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { parse as parse2 } from "smol-toml";
+function loadWhitelist() {
+  const path = resolve2(process.env["HOME"] ?? "~", ".defi", "pools.toml");
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = parse2(raw);
+    return parsed.whitelist ?? [];
+  } catch {
+    return [];
+  }
+}
+
 // src/commands/lp.ts
 function resolveAccount(optOwner) {
   if (optOwner) return optOwner;
@@ -6915,7 +6209,11 @@ function resolvePoolAddress(registry, protocolSlug, pool) {
 function registerLP(parent, getOpts, makeExecutor2) {
   const lp = parent.command("lp").description("Unified LP operations: discover, add, farm, claim, remove, positions");
   lp.command("discover").description("Scan all protocols for fee + emission pools (gauges, farming, LB rewards)").option("--protocol <protocol>", "Filter to a single protocol slug").option("--emission-only", "Only show emission (gauge/farming) pools, skip fee-only").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const rpcUrl = chain.effectiveRpcUrl();
@@ -6970,7 +6268,13 @@ function registerLP(parent, getOpts, makeExecutor2) {
                   moePerDay: p.moePerDay,
                   aprPercent: p.aprPercent,
                   rangeTvlUsd: p.rangeTvlUsd,
-                  isTopPool: p.isTopPool
+                  poolTvlUsd: p.poolTvlUsd,
+                  isTopPool: p.isTopPool,
+                  rewardedBins: p.rewardedBins,
+                  minBinId: p.minBinId,
+                  maxBinId: p.maxBinId,
+                  totalMoePerDay: p.totalMoePerDay,
+                  moePriceUsd: p.moePriceUsd
                 });
               }
             }
@@ -6987,7 +6291,11 @@ function registerLP(parent, getOpts, makeExecutor2) {
   });
   lp.command("add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--recipient <address>", "Recipient address").option("--tick-lower <tick>", "Lower tick for concentrated LP (default: full range)").option("--tick-upper <tick>", "Upper tick for concentrated LP (default: full range)").option("--range <percent>", "\xB1N% concentrated range around current price (e.g. --range 2)").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7013,7 +6321,11 @@ function registerLP(parent, getOpts, makeExecutor2) {
   });
   lp.command("farm").description("Add liquidity and auto-stake into gauge/farming for emissions").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--gauge <address>", "Gauge address (required for solidly/hybra if not resolved automatically)").option("--recipient <address>", "Recipient / owner address").option("--tick-lower <tick>", "Lower tick for concentrated LP").option("--tick-upper <tick>", "Upper tick for concentrated LP").option("--range <percent>", "\xB1N% concentrated range around current price").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7091,7 +6403,11 @@ function registerLP(parent, getOpts, makeExecutor2) {
   });
   lp.command("claim").description("Claim rewards from a pool (fee or emission)").requiredOption("--protocol <protocol>", "Protocol slug").option("--pool <address>", "Pool address (required for farming/LB)").option("--gauge <address>", "Gauge contract address (required for solidly/hybra)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--bins <binIds>", "Comma-separated bin IDs (for Merchant Moe LB)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const rpcUrl = chain.effectiveRpcUrl();
@@ -7138,7 +6454,11 @@ function registerLP(parent, getOpts, makeExecutor2) {
   });
   lp.command("remove").description("Auto-unstake (if staked) and remove liquidity from a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--liquidity <amount>", "Liquidity amount to remove in wei").option("--pool <address>", "Pool address (needed to resolve gauge)").option("--gauge <address>", "Gauge contract address (for solidly/hybra unstake)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--recipient <address>", "Recipient address").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const rpcUrl = chain.effectiveRpcUrl();
@@ -7201,7 +6521,11 @@ function registerLP(parent, getOpts, makeExecutor2) {
     printOutput({ step: "lp_remove", ...removeResult }, getOpts());
   });
   lp.command("positions").description("Show all LP positions across protocols").option("--protocol <protocol>", "Filter to a single protocol slug").option("--pool <address>", "Filter to a specific pool address").option("--bins <binIds>", "Comma-separated bin IDs (for Merchant Moe LB, auto-detected if omitted)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const rpcUrl = chain.effectiveRpcUrl();
@@ -7232,13 +6556,251 @@ function registerLP(parent, getOpts, makeExecutor2) {
     );
     printOutput(results, getOpts());
   });
+  lp.command("autopilot").description("Auto-allocate budget across whitelisted pools (reads ~/.defi/pools.toml)").requiredOption("--budget <usd>", "Total budget in USD").option("--chain <chain>", "Filter whitelist to a specific chain").option("--dry-run", "Show plan only (default)", true).option("--broadcast", "Execute the plan (lending supply supported; LP types show a warning)").action(async (opts) => {
+    const budgetUsd = parseFloat(opts.budget);
+    if (isNaN(budgetUsd) || budgetUsd <= 0) {
+      printOutput({ error: `Invalid budget: ${opts.budget}` }, getOpts());
+      process.exit(1);
+      return;
+    }
+    let whitelist = loadWhitelist();
+    if (whitelist.length === 0) {
+      printOutput(
+        { error: "No pools whitelisted. Create ~/.defi/pools.toml (see config/pools.example.toml)" },
+        getOpts()
+      );
+      process.exit(1);
+      return;
+    }
+    const chainFilter = opts.chain?.toLowerCase();
+    if (chainFilter) {
+      whitelist = whitelist.filter((e) => e.chain.toLowerCase() === chainFilter);
+      if (whitelist.length === 0) {
+        printOutput(
+          { error: `No whitelisted pools found for chain '${chainFilter}'` },
+          getOpts()
+        );
+        process.exit(1);
+        return;
+      }
+    }
+    const registry = Registry.loadEmbedded();
+    const scanned = await Promise.all(
+      whitelist.map(async (entry) => {
+        try {
+          const chainName = entry.chain.toLowerCase();
+          let chain;
+          try {
+            chain = registry.getChain(chainName);
+          } catch {
+            return { entry, scan_error: `Unknown chain '${chainName}'` };
+          }
+          const rpcUrl = chain.effectiveRpcUrl();
+          if (entry.type === "lending" && entry.asset) {
+            const protos = registry.getProtocolsForChain(chainName).filter(
+              (p) => p.category === ProtocolCategory.Lending && p.slug === entry.protocol
+            );
+            if (protos.length === 0) {
+              return { entry, scan_error: `Protocol not found: ${entry.protocol}` };
+            }
+            const proto = protos[0];
+            const assetAddr = registry.resolveToken(chainName, entry.asset).address;
+            const adapter = createLending(proto, rpcUrl);
+            const rates = await adapter.getRates(assetAddr);
+            return { entry, apy: rates.supply_apy };
+          }
+          if (entry.type === "lb" && entry.pool) {
+            const protos = registry.getProtocolsForChain(chainName).filter((p) => p.slug === entry.protocol);
+            if (protos.length === 0) {
+              return { entry, scan_error: `Protocol not found: ${entry.protocol}` };
+            }
+            const proto = protos[0];
+            if (proto.interface === "uniswap_v2" && proto.contracts?.["lb_factory"]) {
+              const adapter = createMerchantMoeLB(proto, rpcUrl);
+              const pools = await adapter.discoverRewardedPools();
+              const match = pools.find(
+                (p) => p.pool.toLowerCase() === entry.pool.toLowerCase() || `${p.symbolX}/${p.symbolY}`.toLowerCase() === entry.pool.toLowerCase() || `${p.symbolY}/${p.symbolX}`.toLowerCase() === entry.pool.toLowerCase()
+              );
+              if (match) {
+                return { entry, apr: match.aprPercent, active: !match.stopped };
+              }
+            }
+            return { entry, scan_error: "Pool not found in LB discovery" };
+          }
+          if (entry.type === "farming" && entry.pool) {
+            const protos = registry.getProtocolsForChain(chainName).filter((p) => p.slug === entry.protocol);
+            if (protos.length === 0) {
+              return { entry, scan_error: `Protocol not found: ${entry.protocol}` };
+            }
+            const proto = protos[0];
+            if (proto.interface === "algebra_v3" && proto.contracts?.["farming_center"]) {
+              const adapter = createKittenSwapFarming(proto, rpcUrl);
+              const pools = await adapter.discoverFarmingPools();
+              const match = pools.find(
+                (p) => p.pool.toLowerCase() === entry.pool.toLowerCase()
+              );
+              if (match) {
+                return { entry, active: match.active };
+              }
+            }
+            return { entry, scan_error: "Pool not found in farming discovery" };
+          }
+          if (entry.type === "gauge" && entry.pool) {
+            const protos = registry.getProtocolsForChain(chainName).filter((p) => p.slug === entry.protocol);
+            if (protos.length === 0) {
+              return { entry, scan_error: `Protocol not found: ${entry.protocol}` };
+            }
+            const proto = protos[0];
+            if (["solidly_v2", "solidly_cl", "algebra_v3", "hybra"].includes(proto.interface)) {
+              const adapter = createGauge(proto, rpcUrl);
+              if (adapter.discoverGaugedPools) {
+                const pools = await adapter.discoverGaugedPools();
+                const poolAddr = entry.pool.startsWith("0x") ? entry.pool.toLowerCase() : void 0;
+                const match = pools.find(
+                  (p) => poolAddr && p.pool.toLowerCase() === poolAddr || `${p.token0}/${p.token1}`.toLowerCase() === entry.pool.toLowerCase() || `${p.token1}/${p.token0}`.toLowerCase() === entry.pool.toLowerCase()
+                );
+                return { entry, active: !!match };
+              }
+            }
+            return { entry, scan_error: "Gauge discovery not supported for this protocol" };
+          }
+          return { entry, scan_error: "Unsupported entry type or missing pool/asset field" };
+        } catch (err) {
+          return { entry, scan_error: String(err) };
+        }
+      })
+    );
+    const RESERVE_PCT = 0.2;
+    const deployableBudget = budgetUsd * (1 - RESERVE_PCT);
+    const reserveUsd = budgetUsd * RESERVE_PCT;
+    const ranked = [...scanned].sort((a, b) => {
+      const scoreA = a.apy ?? a.apr ?? (a.active ? 1 : 0);
+      const scoreB = b.apy ?? b.apr ?? (b.active ? 1 : 0);
+      return scoreB - scoreA;
+    });
+    const allocations = [];
+    let remainingBudget = deployableBudget;
+    for (const s of ranked) {
+      if (remainingBudget <= 0) break;
+      const maxAlloc = budgetUsd * (s.entry.max_allocation_pct / 100);
+      const alloc = Math.min(maxAlloc, remainingBudget);
+      if (alloc <= 0) continue;
+      const item = {
+        protocol: s.entry.protocol,
+        chain: s.entry.chain,
+        type: s.entry.type,
+        amount_usd: Math.round(alloc * 100) / 100
+      };
+      if (s.entry.pool) item["pool"] = s.entry.pool;
+      if (s.entry.asset) item["asset"] = s.entry.asset;
+      if (s.apy !== void 0) item["apy"] = s.apy;
+      if (s.apr !== void 0) item["apr"] = s.apr;
+      if (s.active !== void 0) item["active"] = s.active;
+      if (s.scan_error) item["scan_error"] = s.scan_error;
+      allocations.push(item);
+      remainingBudget -= alloc;
+    }
+    const totalReserved = reserveUsd + remainingBudget;
+    allocations.push({
+      reserve: true,
+      amount_usd: Math.round(totalReserved * 100) / 100,
+      note: "20% safety margin (hardcoded) + unallocated remainder"
+    });
+    let estimatedAnnualYieldUsd = 0;
+    for (const alloc of allocations) {
+      if (alloc["reserve"]) continue;
+      const amt = alloc["amount_usd"];
+      const rate = alloc["apy"] ?? alloc["apr"];
+      if (rate !== void 0 && rate > 0) {
+        estimatedAnnualYieldUsd += amt * rate;
+      }
+    }
+    const estimatedDailyYieldUsd = estimatedAnnualYieldUsd / 365;
+    const isBroadcast = !!opts.broadcast;
+    const plan = {
+      budget_usd: budgetUsd,
+      deployable_usd: Math.round(deployableBudget * 100) / 100,
+      reserve_pct: RESERVE_PCT * 100,
+      allocations,
+      estimated_daily_yield_usd: Math.round(estimatedDailyYieldUsd * 100) / 100,
+      estimated_annual_yield_usd: Math.round(estimatedAnnualYieldUsd * 100) / 100,
+      execution: isBroadcast ? "broadcast" : "dry_run"
+    };
+    printOutput(plan, getOpts());
+    if (!isBroadcast) return;
+    process.stderr.write("\nExecuting autopilot plan...\n");
+    const executor = makeExecutor2();
+    const execResults = [];
+    let allocIndex = 0;
+    const actionAllocs = allocations.filter((a) => !a["reserve"]);
+    for (const alloc of actionAllocs) {
+      allocIndex++;
+      const chainName = alloc["chain"].toLowerCase();
+      let chain;
+      try {
+        chain = registry.getChain(chainName);
+      } catch {
+        process.stderr.write(`
+--- ${allocIndex}/${actionAllocs.length}: ${alloc["protocol"]} \u2014 unknown chain '${chainName}', skipping ---
+`);
+        execResults.push({ ...alloc, exec_status: "skipped", exec_error: `Unknown chain '${chainName}'` });
+        continue;
+      }
+      const rpc = chain.effectiveRpcUrl();
+      process.stderr.write(`
+--- ${allocIndex}/${actionAllocs.length}: ${alloc["protocol"]} (${alloc["type"]}) $${alloc["amount_usd"]} ---
+`);
+      if (alloc["type"] === "lending" && alloc["asset"]) {
+        try {
+          const protocol = registry.getProtocol(alloc["protocol"]);
+          const adapter = createLending(protocol, rpc);
+          const tokenInfo = registry.resolveToken(chainName, alloc["asset"]);
+          const assetAddr = tokenInfo.address;
+          const decimals = tokenInfo.decimals ?? 18;
+          const amountWei = BigInt(Math.floor(alloc["amount_usd"] * 10 ** decimals));
+          const wallet = resolveAccount();
+          const tx = await adapter.buildSupply({
+            protocol: alloc["protocol"],
+            asset: assetAddr,
+            amount: amountWei,
+            on_behalf_of: wallet
+          });
+          process.stderr.write(`  Supplying ${amountWei} wei of ${alloc["asset"]} to ${alloc["protocol"]}...
+`);
+          const result = await executor.execute(tx);
+          process.stderr.write(`  Status: ${result.status}
+`);
+          const explorerUrl = result.details?.["explorer_url"];
+          if (explorerUrl) process.stderr.write(`  Explorer: ${explorerUrl}
+`);
+          execResults.push({ ...alloc, exec_status: result.status, tx_hash: result.tx_hash });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(`  Error: ${msg}
+`);
+          execResults.push({ ...alloc, exec_status: "error", exec_error: msg });
+        }
+        continue;
+      }
+      const lpMsg = `LP execution for type '${alloc["type"]}' pool '${alloc["pool"] ?? ""}' \u2014 requires manual token preparation (swap + addLiquidity not yet automated)`;
+      process.stderr.write(`  Warning: ${lpMsg}
+`);
+      execResults.push({ ...alloc, exec_status: "skipped", exec_note: lpMsg });
+    }
+    process.stderr.write("\nAutopilot execution complete.\n");
+    printOutput({ execution_results: execResults }, getOpts());
+  });
 }
 
 // src/commands/lending.ts
 function registerLending(parent, getOpts, makeExecutor2) {
   const lending = parent.command("lending").description("Lending operations: supply, borrow, repay, withdraw, rates, position");
   lending.command("rates").description("Show current lending rates").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7248,7 +6810,11 @@ function registerLending(parent, getOpts, makeExecutor2) {
     printOutput(rates, getOpts());
   });
   lending.command("position").description("Show current lending position").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--address <address>", "Wallet address to query").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7258,7 +6824,11 @@ function registerLending(parent, getOpts, makeExecutor2) {
   });
   lending.command("supply").description("Supply an asset to a lending protocol").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount to supply in wei").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7271,7 +6841,11 @@ function registerLending(parent, getOpts, makeExecutor2) {
   });
   lending.command("borrow").description("Borrow an asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--rate-mode <mode>", "variable or stable", "variable").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7290,7 +6864,11 @@ function registerLending(parent, getOpts, makeExecutor2) {
   });
   lending.command("repay").description("Repay a borrowed asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--rate-mode <mode>", "variable or stable", "variable").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7309,7 +6887,11 @@ function registerLending(parent, getOpts, makeExecutor2) {
   });
   lending.command("withdraw").description("Withdraw a supplied asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--to <address>", "Recipient address").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
@@ -7322,115 +6904,6 @@ function registerLending(parent, getOpts, makeExecutor2) {
   });
 }
 
-// src/commands/cdp.ts
-function registerCdp(parent, getOpts, makeExecutor2) {
-  const cdp = parent.command("cdp").description("CDP operations: open, adjust, close, info");
-  cdp.command("open").description("Open a new CDP position").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--collateral <token>", "Collateral token address").requiredOption("--amount <amount>", "Collateral amount in wei").requiredOption("--mint <amount>", "Stablecoin to mint in wei").option("--recipient <address>", "Recipient address").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createCdp(protocol, chain.effectiveRpcUrl());
-    const recipient = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildOpen({
-      protocol: protocol.name,
-      collateral: opts.collateral,
-      collateral_amount: BigInt(opts.amount),
-      debt_amount: BigInt(opts.mint),
-      recipient
-    });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  cdp.command("info").description("Show CDP position info, or protocol overview if --position is omitted").requiredOption("--protocol <protocol>", "Protocol slug").option("--position <id>", "CDP/trove ID (omit for protocol overview)").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    if (opts.position === void 0) {
-      printOutput({
-        name: protocol.name,
-        slug: protocol.slug,
-        chain: chainName,
-        contracts: protocol.contracts ?? {}
-      }, getOpts());
-      return;
-    }
-    const adapter = createCdp(protocol, chain.effectiveRpcUrl());
-    const info = await adapter.getCdpInfo(BigInt(opts.position));
-    printOutput(info, getOpts());
-  });
-  cdp.command("adjust").description("Adjust an existing CDP position").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--position <id>", "CDP/trove ID").option("--add-collateral <amount>", "Add collateral in wei").option("--withdraw-collateral <amount>", "Withdraw collateral in wei").option("--mint <amount>", "Mint additional stablecoin").option("--repay <amount>", "Repay stablecoin").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createCdp(protocol, chain.effectiveRpcUrl());
-    const tx = await adapter.buildAdjust({
-      protocol: protocol.name,
-      cdp_id: BigInt(opts.position),
-      collateral_delta: opts.addCollateral ? BigInt(opts.addCollateral) : opts.withdrawCollateral ? BigInt(opts.withdrawCollateral) : void 0,
-      debt_delta: opts.mint ? BigInt(opts.mint) : opts.repay ? BigInt(opts.repay) : void 0,
-      add_collateral: !!opts.addCollateral,
-      add_debt: !!opts.mint
-    });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  cdp.command("close").description("Close a CDP position").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--position <id>", "CDP/trove ID").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createCdp(protocol, chain.effectiveRpcUrl());
-    const tx = await adapter.buildClose({ protocol: protocol.name, cdp_id: BigInt(opts.position) });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-}
-
-// src/commands/vault.ts
-function registerVault(parent, getOpts, makeExecutor2) {
-  const vault = parent.command("vault").description("Vault operations: deposit, withdraw, info");
-  vault.command("deposit").description("Deposit assets into a vault").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--amount <amount>", "Amount in wei").option("--receiver <address>", "Receiver address for vault shares").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createVault(protocol, chain.effectiveRpcUrl());
-    const receiver = opts.receiver ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildDeposit(BigInt(opts.amount), receiver);
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  vault.command("withdraw").description("Withdraw assets from a vault").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--amount <amount>", "Amount in wei (shares)").option("--receiver <address>", "Receiver address").option("--owner <address>", "Owner address").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createVault(protocol, chain.effectiveRpcUrl());
-    const receiver = opts.receiver ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const owner = opts.owner ?? receiver;
-    const tx = await adapter.buildWithdraw(BigInt(opts.amount), receiver, owner);
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  vault.command("info").description("Show vault info (TVL, APY, shares)").requiredOption("--protocol <protocol>", "Protocol slug").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createVault(protocol, chain.effectiveRpcUrl());
-    const info = await adapter.getVaultInfo();
-    printOutput(info, getOpts());
-  });
-}
-
 // src/commands/yield.ts
 function resolveAsset(registry, chain, asset) {
   if (/^0x[0-9a-fA-F]{40}$/.test(asset)) {
@@ -7646,8 +7119,10 @@ function registerYield(parent, getOpts, makeExecutor2) {
     try {
       const registry = Registry.loadEmbedded();
       const asset = opts.asset;
+      const specifiedChain = parent.opts().chain;
+      const chainKeys = specifiedChain ? [specifiedChain.toLowerCase()] : Array.from(registry.chains.keys());
       const allRates = [];
-      for (const [chainKey] of registry.chains) {
+      for (const chainKey of chainKeys) {
         try {
           const chain = registry.getChain(chainKey);
           const rpc = chain.effectiveRpcUrl();
@@ -7676,7 +7151,12 @@ function registerYield(parent, getOpts, makeExecutor2) {
   yieldCmd.command("compare").description("Compare lending rates across protocols for an asset").option("--asset <token>", "Token symbol or address", "USDC").action(async (opts) => {
     try {
       const registry = Registry.loadEmbedded();
-      const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+      const specChain = parent.opts().chain;
+      if (!specChain) {
+        printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+        return;
+      }
+      const chainName = specChain.toLowerCase();
       const chain = registry.getChain(chainName);
       const rpc = chain.effectiveRpcUrl();
       const assetAddr = resolveAsset(registry, chainName, opts.asset);
@@ -7912,7 +7392,12 @@ function registerYield(parent, getOpts, makeExecutor2) {
   yieldCmd.command("optimize").description("Find the optimal yield strategy for an asset").requiredOption("--asset <token>", "Token symbol or address").option("--strategy <strategy>", "Strategy: best-supply, leverage-loop, auto", "auto").option("--amount <amount>", "Amount to deploy (for allocation breakdown)").action(async (opts) => {
     try {
       const registry = Registry.loadEmbedded();
-      const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+      const specChain = parent.opts().chain;
+      if (!specChain) {
+        printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+        return;
+      }
+      const chainName = specChain.toLowerCase();
       const chain = registry.getChain(chainName);
       const rpc = chain.effectiveRpcUrl();
       const asset = opts.asset;
@@ -8044,9 +7529,9 @@ function registerYield(parent, getOpts, makeExecutor2) {
 import { encodeFunctionData as encodeFunctionData28, parseAbi as parseAbi31 } from "viem";
 
 // src/portfolio-tracker.ts
-import { mkdirSync, writeFileSync, readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { mkdirSync, writeFileSync, readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { encodeFunctionData as encodeFunctionData27, parseAbi as parseAbi30 } from "viem";
 var ERC20_ABI4 = parseAbi30([
   "function balanceOf(address owner) external view returns (uint256)"
@@ -8063,7 +7548,7 @@ function decodeU256Word(data, wordOffset = 0) {
   return BigInt("0x" + hex);
 }
 function snapshotDir() {
-  return resolve2(homedir(), ".defi-cli", "snapshots");
+  return resolve3(homedir(), ".defi-cli", "snapshots");
 }
 async function takeSnapshot(chainName, wallet, registry) {
   const chain = registry.getChain(chainName);
@@ -8177,7 +7662,7 @@ function saveSnapshot(snapshot) {
   const dir = snapshotDir();
   mkdirSync(dir, { recursive: true });
   const filename = `${snapshot.chain}_${snapshot.wallet}_${snapshot.timestamp}.json`;
-  const filepath = resolve2(dir, filename);
+  const filepath = resolve3(dir, filename);
   writeFileSync(filepath, JSON.stringify(snapshot, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2));
   return filepath;
 }
@@ -8187,7 +7672,7 @@ function loadSnapshots(chain, wallet, limit = 10) {
   const prefix = `${chain}_${wallet}_`;
   const files = readdirSync2(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".json")).sort().reverse().slice(0, limit);
   return files.map((f) => {
-    const raw = JSON.parse(readFileSync2(resolve2(dir, f), "utf-8"));
+    const raw = JSON.parse(readFileSync3(resolve3(dir, f), "utf-8"));
     if (Array.isArray(raw.tokens)) {
       for (const t of raw.tokens) {
         if (typeof t.balance === "string") t.balance = BigInt(t.balance);
@@ -8258,7 +7743,12 @@ function registerPortfolio(parent, getOpts) {
   portfolio.command("show").description("Show current portfolio positions").requiredOption("--address <address>", "Wallet address to query").action(async (opts) => {
     const mode = getOpts();
     const registry = Registry.loadEmbedded();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+    const _chain = parent.opts().chain;
+    if (!_chain) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
+    const chainName = _chain.toLowerCase();
     let chain;
     try {
       chain = registry.getChain(chainName);
@@ -8396,7 +7886,12 @@ function registerPortfolio(parent, getOpts) {
   });
   portfolio.command("snapshot").description("Take a new portfolio snapshot and save it locally").requiredOption("--address <address>", "Wallet address to snapshot").action(async (opts) => {
     const mode = getOpts();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+    const _chain = parent.opts().chain;
+    if (!_chain) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
+    const chainName = _chain.toLowerCase();
     const registry = Registry.loadEmbedded();
     if (!/^0x[0-9a-fA-F]{40}$/.test(opts.address)) {
       printOutput({ error: `Invalid address: ${opts.address}` }, mode);
@@ -8423,7 +7918,12 @@ function registerPortfolio(parent, getOpts) {
   });
   portfolio.command("pnl").description("Show PnL since the last snapshot").requiredOption("--address <address>", "Wallet address").option("--since <hours>", "Compare against snapshot from N hours ago (default: last snapshot)").action(async (opts) => {
     const mode = getOpts();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+    const _chain = parent.opts().chain;
+    if (!_chain) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
+    const chainName = _chain.toLowerCase();
     const registry = Registry.loadEmbedded();
     if (!/^0x[0-9a-fA-F]{40}$/.test(opts.address)) {
       printOutput({ error: `Invalid address: ${opts.address}` }, mode);
@@ -8468,7 +7968,12 @@ function registerPortfolio(parent, getOpts) {
   });
   portfolio.command("history").description("List saved portfolio snapshots with values").requiredOption("--address <address>", "Wallet address").option("--limit <n>", "Number of snapshots to show", "10").action(async (opts) => {
     const mode = getOpts();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+    const _chain = parent.opts().chain;
+    if (!_chain) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
+    const chainName = _chain.toLowerCase();
     if (!/^0x[0-9a-fA-F]{40}$/.test(opts.address)) {
       printOutput({ error: `Invalid address: ${opts.address}` }, mode);
       return;
@@ -8491,863 +7996,13 @@ function registerPortfolio(parent, getOpts) {
   });
 }
 
-// src/commands/monitor.ts
-async function checkChainLendingPositions(chainKey, registry, address, threshold) {
-  let chain;
-  try {
-    chain = registry.getChain(chainKey);
-  } catch {
-    return [];
-  }
-  const rpc = chain.effectiveRpcUrl();
-  const chainName = chain.name;
-  const protocols = registry.getProtocolsForChain(chainKey).filter(
-    (p) => p.category === ProtocolCategory.Lending
-  );
-  const results = await Promise.all(
-    protocols.map(async (proto) => {
-      try {
-        const adapter = createLending(proto, rpc);
-        const position = await adapter.getUserPosition(address);
-        const hf = position.health_factor ?? Infinity;
-        const totalBorrow = position.borrows?.reduce(
-          (sum, b) => sum + (b.value_usd ?? 0),
-          0
-        ) ?? 0;
-        if (totalBorrow === 0) return null;
-        const totalSupply = position.supplies?.reduce(
-          (sum, s) => sum + (s.value_usd ?? 0),
-          0
-        ) ?? 0;
-        return {
-          chain: chainName,
-          protocol: proto.name,
-          health_factor: hf === Infinity ? 999999 : Math.round(hf * 100) / 100,
-          total_supply_usd: Math.round(totalSupply * 100) / 100,
-          total_borrow_usd: Math.round(totalBorrow * 100) / 100,
-          alert: hf < threshold
-        };
-      } catch {
-        return null;
-      }
-    })
-  );
-  return results.filter((r) => r !== null);
-}
-function registerMonitor(parent, getOpts) {
-  parent.command("monitor").description("Monitor health factor with alerts").option("--protocol <protocol>", "Protocol slug (required unless --all-chains)").requiredOption("--address <address>", "Wallet address to monitor").option("--threshold <hf>", "Health factor alert threshold", "1.5").option("--interval <secs>", "Polling interval in seconds", "60").option("--once", "Run once instead of continuously").option("--all-chains", "Scan all chains for lending positions").action(async (opts) => {
-    const threshold = parseFloat(opts.threshold);
-    const address = opts.address;
-    if (opts.allChains) {
-      const registry = Registry.loadEmbedded();
-      const chainKeys = Array.from(registry.chains.keys());
-      const poll = async () => {
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const chainResults = await Promise.all(
-          chainKeys.map(
-            (ck) => checkChainLendingPositions(ck, registry, address, threshold)
-          )
-        );
-        const positions = chainResults.flat();
-        const alertsCount = positions.filter((p) => p.alert).length;
-        const output = {
-          timestamp,
-          address,
-          threshold,
-          positions,
-          alerts_count: alertsCount
-        };
-        for (const pos of positions) {
-          if (pos.alert) {
-            process.stderr.write(
-              `ALERT: ${pos.chain}/${pos.protocol} HF=${pos.health_factor} < ${threshold}
-`
-            );
-          }
-        }
-        printOutput(output, getOpts());
-      };
-      await poll();
-      if (!opts.once) {
-        const intervalMs = parseInt(opts.interval) * 1e3;
-        const timer = setInterval(poll, intervalMs);
-        process.on("SIGINT", () => {
-          clearInterval(timer);
-          process.exit(0);
-        });
-      }
-    } else {
-      if (!opts.protocol) {
-        printOutput({ error: "Either --protocol or --all-chains is required" }, getOpts());
-        process.exit(1);
-      }
-      const chainName = parent.opts().chain ?? "hyperevm";
-      const registry = Registry.loadEmbedded();
-      const chain = registry.getChain(chainName);
-      const protocol = registry.getProtocol(opts.protocol);
-      const adapter = createLending(protocol, chain.effectiveRpcUrl());
-      const poll = async () => {
-        try {
-          const position = await adapter.getUserPosition(address);
-          const hf = position.health_factor ?? Infinity;
-          const alert = hf < threshold;
-          printOutput({
-            protocol: protocol.name,
-            user: opts.address,
-            health_factor: hf,
-            threshold,
-            alert,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            supplies: position.supplies,
-            borrows: position.borrows
-          }, getOpts());
-        } catch (e) {
-          printOutput({
-            error: e instanceof Error ? e.message : String(e),
-            protocol: protocol.name,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }, getOpts());
-        }
-      };
-      await poll();
-      if (!opts.once) {
-        const intervalMs = parseInt(opts.interval) * 1e3;
-        const timer = setInterval(poll, intervalMs);
-        process.on("SIGINT", () => {
-          clearInterval(timer);
-          process.exit(0);
-        });
-      }
-    }
-  });
-}
-
-// src/commands/alert.ts
-function registerAlert(parent, getOpts) {
-  parent.command("alert").description("Alert on DEX vs Oracle price deviation").option("--threshold <pct>", "Deviation threshold in percent", "5.0").option("--once", "Run once instead of continuously").option("--interval <secs>", "Polling interval in seconds", "60").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const rpcUrl = chain.effectiveRpcUrl();
-    const threshold = parseFloat(opts.threshold);
-    const dexProtocols = registry.getProtocolsByCategory("dex").filter((p) => p.chain === chainName);
-    const lendingProtocols = registry.getProtocolsByCategory("lending").filter((p) => p.chain === chainName);
-    const poll = async () => {
-      const alerts = [];
-      for (const p of dexProtocols) {
-        try {
-          const dex = createDex(p, rpcUrl);
-          alerts.push({
-            protocol: p.name,
-            type: "info",
-            message: `DEX ${dex.name()} active on ${chainName}`
-          });
-        } catch {
-        }
-      }
-      printOutput({
-        chain: chainName,
-        threshold_pct: threshold,
-        alerts,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }, getOpts());
-    };
-    await poll();
-    if (!opts.once) {
-      const intervalMs = parseInt(opts.interval) * 1e3;
-      const timer = setInterval(poll, intervalMs);
-      process.on("SIGINT", () => {
-        clearInterval(timer);
-        process.exit(0);
-      });
-    }
-  });
-}
-
-// src/commands/scan.ts
-import { encodeFunctionData as encodeFunctionData29, parseAbi as parseAbi33 } from "viem";
-var AAVE_ORACLE_ABI = parseAbi33([
-  "function getAssetPrice(address asset) external view returns (uint256)"
-]);
-var UNIV2_ROUTER_ABI = parseAbi33([
-  "function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory)"
-]);
-var VTOKEN_ABI = parseAbi33([
-  "function exchangeRateStored() external view returns (uint256)"
-]);
-var STABLECOINS = /* @__PURE__ */ new Set(["USDC", "USDT", "DAI", "USDT0"]);
-function round2(x) {
-  return Math.round(x * 100) / 100;
-}
-function round4(x) {
-  return Math.round(x * 1e4) / 1e4;
-}
-function round6(x) {
-  return Math.round(x * 1e6) / 1e6;
-}
-function parseU256F64(data, decimals) {
-  if (!data || data.length < 66) return 0;
-  const raw = BigInt(data.slice(0, 66));
-  return Number(raw) / 10 ** decimals;
-}
-function parseAmountsOutLast(data, outDecimals) {
-  if (!data) return 0;
-  const hex = data.startsWith("0x") ? data.slice(2) : data;
-  if (hex.length < 128) return 0;
-  const num = parseInt(hex.slice(64, 128), 16);
-  if (num === 0) return 0;
-  const byteOff = 64 + (num - 1) * 32;
-  const hexOff = byteOff * 2;
-  if (hex.length < hexOff + 64) return 0;
-  const val = BigInt("0x" + hex.slice(hexOff, hexOff + 64));
-  return Number(val) / 10 ** outDecimals;
-}
-function registerScan(parent, getOpts) {
-  parent.command("scan").description("Multi-pattern exploit detection scanner").option("--chain <chain>", "Chain to scan", "hyperevm").option("--patterns <patterns>", "Comma-separated patterns: oracle,stable,exchange_rate", "oracle,stable,exchange_rate").option("--oracle-threshold <pct>", "Oracle divergence threshold (percent)", "5.0").option("--stable-threshold <price>", "Stablecoin depeg threshold (min price)", "0.98").option("--rate-threshold <pct>", "Exchange rate change threshold (percent)", "5.0").option("--interval <secs>", "Polling interval in seconds", "30").option("--once", "Single check then exit").option("--all-chains", "Scan all chains in parallel").action(async (opts) => {
-    try {
-      const registry = Registry.loadEmbedded();
-      const oracleThreshold = parseFloat(opts.oracleThreshold ?? "5.0");
-      const stableThreshold = parseFloat(opts.stableThreshold ?? "0.98");
-      const rateThreshold = parseFloat(opts.rateThreshold ?? "5.0");
-      const interval = parseInt(opts.interval ?? "30", 10);
-      const patterns = opts.patterns ?? "oracle,stable,exchange_rate";
-      const once = !!opts.once;
-      if (opts.allChains) {
-        const result = await runAllChains(registry, patterns, oracleThreshold, stableThreshold, rateThreshold);
-        printOutput(result, getOpts());
-        return;
-      }
-      const chainName = (opts.chain ?? "hyperevm").toLowerCase();
-      const chain = registry.getChain(chainName);
-      const rpc = chain.effectiveRpcUrl();
-      const pats = patterns.split(",").map((s) => s.trim());
-      const doOracle = pats.includes("oracle");
-      const doStable = pats.includes("stable");
-      const doRate = pats.includes("exchange_rate");
-      const allTokens = registry.tokens.get(chainName) ?? [];
-      const wrappedNative = chain.wrapped_native;
-      const quoteStable = (() => {
-        for (const sym of ["USDT", "USDC", "USDT0"]) {
-          try {
-            return registry.resolveToken(chainName, sym);
-          } catch {
-          }
-        }
-        return null;
-      })();
-      if (!quoteStable) {
-        printOutput({ error: `No stablecoin found on chain ${chainName}` }, getOpts());
-        return;
-      }
-      const scanTokens = allTokens.filter(
-        (t) => t.address !== "0x0000000000000000000000000000000000000000" && !STABLECOINS.has(t.symbol)
-      );
-      const oracles = registry.getProtocolsForChain(chainName).filter(
-        (p) => p.category === ProtocolCategory.Lending && (p.interface === "aave_v3" || p.interface === "aave_v2" || p.interface === "aave_v3_isolated")
-      ).flatMap((p) => {
-        const oracleAddr = p.contracts?.["oracle"];
-        if (!oracleAddr) return [];
-        const decimals = p.interface === "aave_v2" ? 18 : 8;
-        return [{ name: p.name, addr: oracleAddr, decimals }];
-      });
-      const dexProto = registry.getProtocolsForChain(chainName).find((p) => p.category === ProtocolCategory.Dex && p.interface === "uniswap_v2");
-      const dexRouter = dexProto?.contracts?.["router"];
-      const compoundForks = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "compound_v2").map((p) => ({
-        name: p.name,
-        vtokens: Object.entries(p.contracts ?? {}).filter(([k]) => k.startsWith("v")).map(([k, a]) => ({ key: k, addr: a }))
-      }));
-      const usdc = (() => {
-        try {
-          return registry.resolveToken(chainName, "USDC");
-        } catch {
-          return null;
-        }
-      })();
-      const usdt = (() => {
-        try {
-          return registry.resolveToken(chainName, "USDT");
-        } catch {
-          return null;
-        }
-      })();
-      const prevRates = /* @__PURE__ */ new Map();
-      const runOnce = async () => {
-        const timestamp = Math.floor(Date.now() / 1e3);
-        const t0 = Date.now();
-        const calls = [];
-        const callTypes = [];
-        if (doOracle) {
-          for (const oracle of oracles) {
-            for (const token of scanTokens) {
-              callTypes.push({ kind: "oracle", oracle: oracle.name, token: token.symbol, oracleDecimals: oracle.decimals });
-              calls.push([
-                oracle.addr,
-                encodeFunctionData29({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })
-              ]);
-            }
-          }
-          if (dexRouter) {
-            for (const token of scanTokens) {
-              const amountIn = BigInt(10) ** BigInt(token.decimals);
-              const path = wrappedNative && token.address.toLowerCase() === wrappedNative.toLowerCase() ? [token.address, quoteStable.address] : wrappedNative ? [token.address, wrappedNative, quoteStable.address] : [token.address, quoteStable.address];
-              callTypes.push({ kind: "dex", token: token.symbol, outDecimals: quoteStable.decimals });
-              calls.push([
-                dexRouter,
-                encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [amountIn, path] })
-              ]);
-            }
-          }
-        }
-        if (doStable && usdc && usdt && dexRouter) {
-          callTypes.push({ kind: "stable", from: "USDC", to: "USDT", outDecimals: usdt.decimals });
-          calls.push([
-            dexRouter,
-            encodeFunctionData29({
-              abi: UNIV2_ROUTER_ABI,
-              functionName: "getAmountsOut",
-              args: [BigInt(10) ** BigInt(usdc.decimals), [usdc.address, usdt.address]]
-            })
-          ]);
-          callTypes.push({ kind: "stable", from: "USDT", to: "USDC", outDecimals: usdc.decimals });
-          calls.push([
-            dexRouter,
-            encodeFunctionData29({
-              abi: UNIV2_ROUTER_ABI,
-              functionName: "getAmountsOut",
-              args: [BigInt(10) ** BigInt(usdt.decimals), [usdt.address, usdc.address]]
-            })
-          ]);
-        }
-        if (doRate) {
-          for (const fork of compoundForks) {
-            for (const { key, addr } of fork.vtokens) {
-              callTypes.push({ kind: "exchangeRate", protocol: fork.name, vtoken: key });
-              calls.push([addr, encodeFunctionData29({ abi: VTOKEN_ABI, functionName: "exchangeRateStored", args: [] })]);
-            }
-          }
-        }
-        if (calls.length === 0) {
-          printOutput({ error: `No scannable resources found on ${chainName}` }, getOpts());
-          return;
-        }
-        const results = await multicallRead(rpc, calls);
-        const scanMs = Date.now() - t0;
-        const alerts = [];
-        const oracleByToken = /* @__PURE__ */ new Map();
-        const dexByToken = /* @__PURE__ */ new Map();
-        const oracleData = {};
-        const dexData = {};
-        const stableData = {};
-        const stablePrices = [];
-        const rateData = {};
-        for (let i = 0; i < callTypes.length; i++) {
-          const ct = callTypes[i];
-          const raw = results[i] ?? null;
-          if (ct.kind === "oracle") {
-            const price = parseU256F64(raw, ct.oracleDecimals);
-            if (price > 0) {
-              const existing = oracleByToken.get(ct.token) ?? [];
-              existing.push({ oracle: ct.oracle, price });
-              oracleByToken.set(ct.token, existing);
-              oracleData[`${ct.oracle}/${ct.token}`] = round4(price);
-            }
-          } else if (ct.kind === "dex") {
-            const price = parseAmountsOutLast(raw, ct.outDecimals);
-            if (price > 0) {
-              dexByToken.set(ct.token, price);
-              dexData[ct.token] = round4(price);
-            }
-          } else if (ct.kind === "stable") {
-            const price = parseAmountsOutLast(raw, ct.outDecimals);
-            if (price <= 0) continue;
-            const pair = `${ct.from}/${ct.to}`;
-            stableData[pair] = round4(price);
-            stablePrices.push({ asset: ct.from, pair, price });
-          } else if (ct.kind === "exchangeRate") {
-            const rate = parseU256F64(raw, 18);
-            const key = `${ct.protocol}/${ct.vtoken}`;
-            rateData[key] = round6(rate);
-            if (rate > 0) {
-              const prev = prevRates.get(key);
-              if (prev !== void 0) {
-                const change = Math.abs((rate - prev) / prev * 100);
-                if (change > rateThreshold) {
-                  const severity = change > 50 ? "critical" : change > 20 ? "high" : "medium";
-                  alerts.push({
-                    pattern: "exchange_rate_anomaly",
-                    severity,
-                    protocol: ct.protocol,
-                    vtoken: ct.vtoken,
-                    prev_rate: round6(prev),
-                    curr_rate: round6(rate),
-                    change_pct: round2(change),
-                    action: `possible donation attack on ${ct.protocol} ${ct.vtoken}`
-                  });
-                }
-              }
-              prevRates.set(key, rate);
-            }
-          }
-        }
-        if (stablePrices.length >= 2) {
-          const allBelow = stablePrices.every((s) => s.price < stableThreshold);
-          if (!allBelow) {
-            for (const { asset, pair, price } of stablePrices) {
-              if (price < stableThreshold) {
-                const severity = price < 0.95 ? "critical" : "high";
-                alerts.push({
-                  pattern: "stablecoin_depeg",
-                  severity,
-                  asset,
-                  pair,
-                  price: round4(price),
-                  threshold: stableThreshold,
-                  action: `buy ${asset} at $${round4(price)}, wait for repeg`
-                });
-              }
-            }
-          }
-        } else {
-          for (const { asset, pair, price } of stablePrices) {
-            if (price < stableThreshold) {
-              const severity = price < 0.95 ? "critical" : "high";
-              alerts.push({
-                pattern: "stablecoin_depeg",
-                severity,
-                asset,
-                pair,
-                price: round4(price),
-                threshold: stableThreshold,
-                action: `buy ${asset} at $${round4(price)}, wait for repeg`
-              });
-            }
-          }
-        }
-        if (doOracle) {
-          for (const [token, oracleEntries] of oracleByToken) {
-            const dexPrice = dexByToken.get(token);
-            if (dexPrice === void 0) continue;
-            for (const { oracle, price: oraclePrice } of oracleEntries) {
-              if (dexPrice < oraclePrice && dexPrice < oraclePrice * 0.1) continue;
-              const deviation = Math.abs(dexPrice - oraclePrice) / oraclePrice * 100;
-              if (deviation > oracleThreshold) {
-                const severity = deviation > 100 ? "critical" : deviation > 20 ? "high" : "medium";
-                const action = dexPrice > oraclePrice ? `borrow ${token} from ${oracle}, sell on DEX` : `buy ${token} on DEX, use as collateral on ${oracle}`;
-                alerts.push({
-                  pattern: "oracle_divergence",
-                  severity,
-                  asset: token,
-                  oracle,
-                  oracle_price: round4(oraclePrice),
-                  dex_price: round4(dexPrice),
-                  deviation_pct: round2(deviation),
-                  action
-                });
-              }
-            }
-          }
-        }
-        const data = {};
-        if (Object.keys(oracleData).length > 0) data["oracle_prices"] = oracleData;
-        if (Object.keys(dexData).length > 0) data["dex_prices"] = dexData;
-        if (Object.keys(stableData).length > 0) data["stablecoin_pegs"] = stableData;
-        if (Object.keys(rateData).length > 0) data["exchange_rates"] = rateData;
-        const output = {
-          timestamp,
-          chain: chain.name,
-          scan_duration_ms: scanMs,
-          patterns,
-          alert_count: alerts.length,
-          alerts,
-          data
-        };
-        for (const alert of alerts) {
-          process.stderr.write(
-            `ALERT [${alert["severity"]}]: ${alert["pattern"]} \u2014 ${alert["action"]}
-`
-          );
-        }
-        printOutput(output, getOpts());
-      };
-      await runOnce();
-      if (!once) {
-        const intervalMs = interval * 1e3;
-        const loop = async () => {
-          await new Promise((r) => setTimeout(r, intervalMs));
-          await runOnce();
-          void loop();
-        };
-        await loop();
-      }
-    } catch (err) {
-      printOutput({ error: String(err) }, getOpts());
-      process.exit(1);
-    }
-  });
-}
-async function runAllChains(registry, patterns, oracleThreshold, stableThreshold, _rateThreshold) {
-  const t0 = Date.now();
-  const chainKeys = Array.from(registry.chains.keys());
-  const tasks = chainKeys.map(async (ck) => {
-    try {
-      const chain = registry.getChain(ck);
-      const rpc = chain.effectiveRpcUrl();
-      const chainName = chain.name.toLowerCase();
-      const allTokens = registry.tokens.get(chainName) ?? [];
-      const wrappedNative = chain.wrapped_native;
-      const quoteStable = (() => {
-        for (const sym of ["USDT", "USDC", "USDT0"]) {
-          try {
-            return registry.resolveToken(chainName, sym);
-          } catch {
-          }
-        }
-        return null;
-      })();
-      if (!quoteStable) return null;
-      const scanTokens = allTokens.filter(
-        (t) => t.address !== "0x0000000000000000000000000000000000000000" && !STABLECOINS.has(t.symbol)
-      );
-      const pats = patterns.split(",").map((s) => s.trim());
-      const doOracle = pats.includes("oracle");
-      const doStable = pats.includes("stable");
-      const oracles = registry.getProtocolsForChain(chainName).filter(
-        (p) => p.category === ProtocolCategory.Lending && (p.interface === "aave_v3" || p.interface === "aave_v2" || p.interface === "aave_v3_isolated")
-      ).flatMap((p) => {
-        const oracleAddr = p.contracts?.["oracle"];
-        if (!oracleAddr) return [];
-        return [{ name: p.name, addr: oracleAddr, decimals: p.interface === "aave_v2" ? 18 : 8 }];
-      });
-      const dexProto = registry.getProtocolsForChain(chainName).find((p) => p.category === ProtocolCategory.Dex && p.interface === "uniswap_v2");
-      const dexRouter = dexProto?.contracts?.["router"];
-      const usdc = (() => {
-        try {
-          return registry.resolveToken(chainName, "USDC");
-        } catch {
-          return null;
-        }
-      })();
-      const usdt = (() => {
-        try {
-          return registry.resolveToken(chainName, "USDT");
-        } catch {
-          return null;
-        }
-      })();
-      const calls = [];
-      const cts = [];
-      if (doOracle) {
-        for (const oracle of oracles) {
-          for (const token of scanTokens) {
-            cts.push({ kind: "oracle", oracle: oracle.name, token: token.symbol, dec: oracle.decimals });
-            calls.push([oracle.addr, encodeFunctionData29({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })]);
-          }
-        }
-        if (dexRouter) {
-          for (const token of scanTokens) {
-            const path = wrappedNative && token.address.toLowerCase() === wrappedNative.toLowerCase() ? [token.address, quoteStable.address] : wrappedNative ? [token.address, wrappedNative, quoteStable.address] : [token.address, quoteStable.address];
-            cts.push({ kind: "dex", token: token.symbol, dec: quoteStable.decimals });
-            calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(token.decimals), path] })]);
-          }
-        }
-      }
-      if (doStable && usdc && usdt && dexRouter) {
-        cts.push({ kind: "stable", from: "USDC", to: "USDT", dec: usdt.decimals });
-        calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdc.decimals), [usdc.address, usdt.address]] })]);
-        cts.push({ kind: "stable", from: "USDT", to: "USDC", dec: usdc.decimals });
-        calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdt.decimals), [usdt.address, usdc.address]] })]);
-      }
-      if (calls.length === 0) return null;
-      const ct0 = Date.now();
-      const results = await multicallRead(rpc, calls);
-      const scanMs = Date.now() - ct0;
-      const alerts = [];
-      const oracleByToken = /* @__PURE__ */ new Map();
-      const dexByToken = /* @__PURE__ */ new Map();
-      const stablePrices = [];
-      for (let i = 0; i < cts.length; i++) {
-        const ct = cts[i];
-        const raw = results[i] ?? null;
-        if (ct.kind === "oracle") {
-          const price = parseU256F64(raw, ct.dec);
-          if (price > 0) {
-            const existing = oracleByToken.get(ct.token) ?? [];
-            existing.push({ oracle: ct.oracle, price });
-            oracleByToken.set(ct.token, existing);
-          }
-        } else if (ct.kind === "dex") {
-          const price = parseAmountsOutLast(raw, ct.dec);
-          if (price > 0) dexByToken.set(ct.token, price);
-        } else if (ct.kind === "stable") {
-          const price = parseAmountsOutLast(raw, ct.dec);
-          if (price > 0) stablePrices.push({ asset: ct.from, pair: `${ct.from}/${ct.to}`, price });
-        }
-      }
-      if (stablePrices.length >= 2) {
-        const allBelow = stablePrices.every((s) => s.price < stableThreshold);
-        if (!allBelow) {
-          for (const { asset, pair, price } of stablePrices) {
-            if (price < stableThreshold) {
-              alerts.push({ pattern: "stablecoin_depeg", severity: price < 0.95 ? "critical" : "high", asset, pair, price: round4(price) });
-            }
-          }
-        }
-      }
-      for (const [token, oEntries] of oracleByToken) {
-        const dp = dexByToken.get(token);
-        if (dp === void 0) continue;
-        for (const { oracle, price: op } of oEntries) {
-          if (dp < op && dp < op * 0.1) continue;
-          const dev = Math.abs(dp - op) / op * 100;
-          if (dev > oracleThreshold) {
-            const sev = dev > 100 ? "critical" : dev > 20 ? "high" : "medium";
-            alerts.push({
-              pattern: "oracle_divergence",
-              severity: sev,
-              asset: token,
-              oracle,
-              oracle_price: round4(op),
-              dex_price: round4(dp),
-              deviation_pct: round2(dev),
-              action: dp > op ? `borrow ${token} from ${oracle}, sell on DEX` : `buy ${token} on DEX, collateral on ${oracle}`
-            });
-          }
-        }
-      }
-      return { chain: chain.name, scan_duration_ms: scanMs, alert_count: alerts.length, alerts };
-    } catch {
-      return null;
-    }
-  });
-  const chainResults = (await Promise.all(tasks)).filter(Boolean);
-  chainResults.sort((a, b) => {
-    const ac = a["alert_count"] ?? 0;
-    const bc = b["alert_count"] ?? 0;
-    return bc - ac;
-  });
-  const totalAlerts = chainResults.reduce((sum, r) => sum + (r["alert_count"] ?? 0), 0);
-  return {
-    mode: "all_chains",
-    chains_scanned: chainKeys.length,
-    scan_duration_ms: Date.now() - t0,
-    total_alerts: totalAlerts,
-    chains: chainResults
-  };
-}
-
-// src/commands/positions.ts
-import { encodeFunctionData as encodeFunctionData30, parseAbi as parseAbi34 } from "viem";
-var ERC20_ABI6 = parseAbi34([
-  "function balanceOf(address owner) external view returns (uint256)"
-]);
-var POOL_ABI5 = parseAbi34([
-  "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
-]);
-var ORACLE_ABI6 = parseAbi34([
-  "function getAssetPrice(address asset) external view returns (uint256)"
-]);
-function round22(x) {
-  return Math.round(x * 100) / 100;
-}
-function round42(x) {
-  return Math.round(x * 1e4) / 1e4;
-}
-function estimateTokenValue(symbol, balance, nativePrice) {
-  const s = symbol.toUpperCase();
-  if (s.includes("USD") || s.includes("DAI")) return balance;
-  if (s.includes("BTC") || s.includes("FBTC")) return balance * 75e3;
-  if (["WETH", "ETH", "METH", "CBETH", "WSTETH"].includes(s)) return balance * 2350;
-  return balance * nativePrice;
-}
-function decodeU2563(data, offset = 0) {
-  if (!data || data.length < 2 + (offset + 32) * 2) return 0n;
-  const hex = data.slice(2 + offset * 64, 2 + offset * 64 + 64);
-  return BigInt("0x" + hex);
-}
-async function scanSingleChain(chainName, rpc, user, tokens, lendingPools, oracleAddr, wrappedNative) {
-  const calls = [];
-  const callTypes = [];
-  for (const token of tokens) {
-    if (token.address !== "0x0000000000000000000000000000000000000000") {
-      callTypes.push({ kind: "token", symbol: token.symbol, decimals: token.decimals });
-      calls.push([
-        token.address,
-        encodeFunctionData30({ abi: ERC20_ABI6, functionName: "balanceOf", args: [user] })
-      ]);
-    }
-  }
-  for (const { name, pool, iface } of lendingPools) {
-    callTypes.push({ kind: "lending", protocol: name, iface });
-    calls.push([
-      pool,
-      encodeFunctionData30({ abi: POOL_ABI5, functionName: "getUserAccountData", args: [user] })
-    ]);
-  }
-  if (oracleAddr) {
-    callTypes.push({ kind: "native_price" });
-    calls.push([
-      oracleAddr,
-      encodeFunctionData30({ abi: ORACLE_ABI6, functionName: "getAssetPrice", args: [wrappedNative] })
-    ]);
-  }
-  if (calls.length === 0) return null;
-  let results;
-  try {
-    results = await multicallRead(rpc, calls);
-  } catch {
-    return null;
-  }
-  const nativePrice = oracleAddr ? Number(decodeU2563(results[results.length - 1])) / 1e8 : 0;
-  const tokenBalances = [];
-  const lendingPositions = [];
-  let chainValue = 0;
-  let totalColl = 0;
-  let totalDebt = 0;
-  for (let i = 0; i < callTypes.length; i++) {
-    const ct = callTypes[i];
-    const data = results[i] ?? null;
-    if (ct.kind === "token") {
-      const balance = decodeU2563(data);
-      if (balance > 0n) {
-        const balF64 = Number(balance) / 10 ** ct.decimals;
-        const valueUsd = estimateTokenValue(ct.symbol, balF64, nativePrice);
-        if (valueUsd > 0.01) {
-          chainValue += valueUsd;
-          tokenBalances.push({
-            symbol: ct.symbol,
-            balance: round42(balF64),
-            value_usd: round22(valueUsd)
-          });
-        }
-      }
-    } else if (ct.kind === "lending") {
-      if (data && data.length >= 2 + 192 * 2) {
-        const priceDecimals = ct.iface === "aave_v2" ? 18 : 8;
-        const divisor = 10 ** priceDecimals;
-        const collateral = Number(decodeU2563(data, 0)) / divisor;
-        const debt = Number(decodeU2563(data, 1)) / divisor;
-        const hfRaw = decodeU2563(data, 5);
-        let hf = null;
-        if (hfRaw <= BigInt("0xffffffffffffffffffffffffffffffff")) {
-          const v = Number(hfRaw) / 1e18;
-          hf = v > 1e10 ? null : round22(v);
-        }
-        if (collateral > 0.01 || debt > 0.01) {
-          const net = collateral - debt;
-          chainValue += net;
-          totalColl += collateral;
-          totalDebt += debt;
-          lendingPositions.push({
-            protocol: ct.protocol,
-            collateral_usd: round22(collateral),
-            debt_usd: round22(debt),
-            net_usd: round22(net),
-            health_factor: hf
-          });
-        }
-      }
-    }
-  }
-  if (tokenBalances.length === 0 && lendingPositions.length === 0) return null;
-  return {
-    chain_name: chainName,
-    native_price: nativePrice,
-    chain_value: chainValue,
-    collateral: totalColl,
-    debt: totalDebt,
-    token_balances: tokenBalances,
-    lending_positions: lendingPositions
-  };
-}
-function registerPositions(parent, getOpts) {
-  parent.command("positions").description("Cross-chain position scanner: find all your positions everywhere").requiredOption("--address <address>", "Wallet address to scan").option("--chains <chains>", "Comma-separated chain names (omit for all)").action(async (opts) => {
-    const mode = getOpts();
-    const registry = Registry.loadEmbedded();
-    const user = opts.address;
-    if (!/^0x[0-9a-fA-F]{40}$/.test(user)) {
-      printOutput({ error: `Invalid address: ${opts.address}` }, mode);
-      return;
-    }
-    const chainFilter = opts.chains ? opts.chains.split(",").map((s) => s.trim().toLowerCase()) : null;
-    const chainKeys = chainFilter ?? Array.from(registry.chains.keys());
-    const start = Date.now();
-    const scanParams = [];
-    for (const chainKey of chainKeys) {
-      let chain;
-      try {
-        chain = registry.getChain(chainKey);
-      } catch {
-        continue;
-      }
-      const rpc = chain.effectiveRpcUrl();
-      const rawTokens = registry.tokens.get(chainKey) ?? [];
-      const tokens = rawTokens.map((t) => ({
-        address: t.address,
-        symbol: t.symbol,
-        decimals: t.decimals
-      }));
-      const chainProtocols = registry.getProtocolsForChain(chainKey);
-      const lendingPools = chainProtocols.filter(
-        (p) => p.category === ProtocolCategory.Lending && (p.interface === "aave_v3" || p.interface === "aave_v2")
-      ).filter((p) => p.contracts?.["pool"]).map((p) => ({
-        name: p.name,
-        pool: p.contracts["pool"],
-        iface: p.interface
-      }));
-      const oracleEntry = chainProtocols.find(
-        (p) => p.interface === "aave_v3" && p.contracts?.["oracle"]
-      );
-      const oracleAddr = oracleEntry?.contracts?.["oracle"];
-      const wrappedNative = chain.wrapped_native ?? "0x5555555555555555555555555555555555555555";
-      scanParams.push({ chainName: chain.name, rpc, tokens, lendingPools, oracleAddr, wrappedNative });
-    }
-    const chainResultsRaw = await Promise.all(
-      scanParams.map(
-        (p) => scanSingleChain(p.chainName, p.rpc, user, p.tokens, p.lendingPools, p.oracleAddr, p.wrappedNative)
-      )
-    );
-    let grandTotalUsd = 0;
-    let totalCollateralUsd = 0;
-    let totalDebtUsd = 0;
-    const chainResults = chainResultsRaw.filter((r) => r !== null).map((r) => {
-      grandTotalUsd += r.chain_value;
-      totalCollateralUsd += r.collateral;
-      totalDebtUsd += r.debt;
-      return {
-        chain: r.chain_name,
-        native_price_usd: round22(r.native_price),
-        chain_total_usd: round22(r.chain_value),
-        token_balances: r.token_balances,
-        lending_positions: r.lending_positions
-      };
-    }).sort((a, b) => b.chain_total_usd - a.chain_total_usd);
-    const scanMs = Date.now() - start;
-    printOutput(
-      {
-        address: user,
-        scan_duration_ms: scanMs,
-        chains_scanned: chainKeys.length,
-        chains_with_positions: chainResults.length,
-        summary: {
-          total_value_usd: round22(grandTotalUsd),
-          total_collateral_usd: round22(totalCollateralUsd),
-          total_debt_usd: round22(totalDebtUsd),
-          net_lending_usd: round22(totalCollateralUsd - totalDebtUsd)
-        },
-        chains: chainResults
-      },
-      mode
-    );
-  });
-}
-
-// src/commands/price.ts
-function round23(x) {
-  return Math.round(x * 100) / 100;
-}
-function resolveAsset2(registry, chain, asset) {
-  if (/^0x[0-9a-fA-F]{40}$/.test(asset)) {
-    return { address: asset, symbol: asset, decimals: 18 };
+// src/commands/price.ts
+function round2(x) {
+  return Math.round(x * 100) / 100;
+}
+function resolveAsset2(registry, chain, asset) {
+  if (/^0x[0-9a-fA-F]{40}$/.test(asset)) {
+    return { address: asset, symbol: asset, decimals: 18 };
   }
   const token = registry.resolveToken(chain, asset);
   return { address: token.address, symbol: token.symbol, decimals: token.decimals };
@@ -9357,7 +8012,12 @@ function registerPrice(parent, getOpts) {
   parent.command("price").description("Query asset prices from oracles and DEXes").requiredOption("--asset <token>", "Token symbol or address").option("--source <source>", "Price source: oracle, dex, or all", "all").action(async (opts) => {
     const mode = getOpts();
     const registry = Registry.loadEmbedded();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+    const _chain = parent.opts().chain;
+    if (!_chain) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
+    const chainName = _chain.toLowerCase();
     let chain;
     try {
       chain = registry.getChain(chainName);
@@ -9470,10 +8130,10 @@ function registerPrice(parent, getOpts) {
       prices: allPrices.map((p) => ({
         source: p.source,
         source_type: p.source_type,
-        price: round23(p.price_f64)
+        price: round2(p.price_f64)
       })),
-      max_spread_pct: round23(maxSpreadPct),
-      oracle_vs_dex_spread_pct: round23(oracleVsDexSpreadPct)
+      max_spread_pct: round2(maxSpreadPct),
+      oracle_vs_dex_spread_pct: round2(oracleVsDexSpreadPct)
     };
     printOutput(report, mode);
   });
@@ -9484,7 +8144,11 @@ import { createPublicClient as createPublicClient23, http as http23, formatEther
 function registerWallet(parent, getOpts) {
   const wallet = parent.command("wallet").description("Wallet management");
   wallet.command("balance").description("Show native token balance").requiredOption("--address <address>", "Wallet address to query").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const client = createPublicClient23({ transport: http23(chain.effectiveRpcUrl()) });
@@ -9508,7 +8172,11 @@ import { createPublicClient as createPublicClient24, http as http24, maxUint256
 function registerToken(parent, getOpts, makeExecutor2) {
   const token = parent.command("token").description("Token operations: approve, allowance, transfer, balance");
   token.command("balance").description("Query token balance for an address").requiredOption("--token <token>", "Token symbol or address").requiredOption("--owner <address>", "Wallet address to query").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const client = createPublicClient24({ transport: http24(chain.effectiveRpcUrl()) });
@@ -9528,7 +8196,11 @@ function registerToken(parent, getOpts, makeExecutor2) {
   });
   token.command("approve").description("Approve a spender for a token").requiredOption("--token <token>", "Token symbol or address").requiredOption("--spender <address>", "Spender address").option("--amount <amount>", "Amount to approve (use 'max' for unlimited)", "max").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const tokenAddr = opts.token.startsWith("0x") ? opts.token : registry.resolveToken(chainName, opts.token).address;
     const amount = opts.amount === "max" ? maxUint256 : BigInt(opts.amount);
@@ -9537,7 +8209,11 @@ function registerToken(parent, getOpts, makeExecutor2) {
     printOutput(result, getOpts());
   });
   token.command("allowance").description("Check token allowance").requiredOption("--token <token>", "Token symbol or address").requiredOption("--owner <address>", "Owner address").requiredOption("--spender <address>", "Spender address").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
     const client = createPublicClient24({ transport: http24(chain.effectiveRpcUrl()) });
@@ -9552,7 +8228,11 @@ function registerToken(parent, getOpts, makeExecutor2) {
   });
   token.command("transfer").description("Transfer tokens to an address").requiredOption("--token <token>", "Token symbol or address").requiredOption("--to <address>", "Recipient address").requiredOption("--amount <amount>", "Amount to transfer (in wei)").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const tokenAddr = opts.token.startsWith("0x") ? opts.token : registry.resolveToken(chainName, opts.token).address;
     const tx = buildTransfer(tokenAddr, opts.to, BigInt(opts.amount));
@@ -9561,192 +8241,6 @@ function registerToken(parent, getOpts, makeExecutor2) {
   });
 }
 
-// src/commands/whales.ts
-import { encodeFunctionData as encodeFunctionData31, parseAbi as parseAbi35 } from "viem";
-var POOL_ABI6 = parseAbi35([
-  "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
-]);
-function round24(x) {
-  return Math.round(x * 100) / 100;
-}
-function round43(x) {
-  return Math.round(x * 1e4) / 1e4;
-}
-function decodeU2564(data, wordOffset = 0) {
-  if (!data || data.length < 2 + (wordOffset + 1) * 64) return 0n;
-  const hex = data.slice(2 + wordOffset * 64, 2 + wordOffset * 64 + 64);
-  return BigInt("0x" + hex);
-}
-function getExplorerApi(chainId, explorerUrl) {
-  const routescanChains = [1, 43114, 10, 5e3];
-  if (routescanChains.includes(chainId)) {
-    return {
-      base: `https://api.routescan.io/v2/network/mainnet/evm/${chainId}/etherscan/api`
-    };
-  }
-  const apiKey = process.env["ETHERSCAN_API_KEY"];
-  if (apiKey) {
-    return {
-      base: `https://api.etherscan.io/v2/api?chainid=${chainId}`,
-      apiKey
-    };
-  }
-  return null;
-}
-function registerWhales(parent, getOpts) {
-  parent.command("whales").description("Find top token holders (whales) and their positions").requiredOption("--token <token>", "Token symbol or address").option("--top <n>", "Number of top holders to show", "10").option("--positions", "Also scan each whale's lending positions").action(async (opts) => {
-    const mode = getOpts();
-    const registry = Registry.loadEmbedded();
-    const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
-    let chain;
-    try {
-      chain = registry.getChain(chainName);
-    } catch {
-      printOutput({ error: `Chain not found: ${chainName}` }, mode);
-      return;
-    }
-    const rpc = chain.effectiveRpcUrl();
-    const top = parseInt(opts.top, 10) || 10;
-    let token;
-    try {
-      token = registry.resolveToken(chainName, opts.token);
-    } catch {
-      printOutput({ error: `Token not found: ${opts.token}` }, mode);
-      return;
-    }
-    const explorerApi = getExplorerApi(chain.chain_id, chain.explorer_url);
-    if (!explorerApi) {
-      printOutput(
-        {
-          error: `No explorer API available for ${chain.name} (chain_id: ${chain.chain_id}). Set ETHERSCAN_API_KEY to enable.`
-        },
-        mode
-      );
-      return;
-    }
-    const tokenAddr = token.address;
-    let url = `${explorerApi.base}?module=token&action=tokenholderlist&contractaddress=${tokenAddr}&page=1&offset=${top}`;
-    if (explorerApi.apiKey) {
-      url += `&apikey=${explorerApi.apiKey}`;
-    }
-    let body;
-    try {
-      const resp = await fetch(url);
-      body = await resp.json();
-    } catch (e) {
-      printOutput({ error: `Explorer API request failed: ${e instanceof Error ? e.message : String(e)}` }, mode);
-      return;
-    }
-    if (body.status !== "1") {
-      const msg = typeof body.result === "string" ? body.result : "Unknown error";
-      if (msg.includes("API Key") || msg.includes("apikey")) {
-        printOutput(
-          { error: "Explorer API requires API key. Set ETHERSCAN_API_KEY environment variable." },
-          mode
-        );
-        return;
-      }
-      printOutput({ error: `Explorer API error: ${msg}` }, mode);
-      return;
-    }
-    const holders = Array.isArray(body.result) ? body.result : [];
-    const whaleList = [];
-    for (const h of holders) {
-      const addrStr = h["TokenHolderAddress"] ?? "";
-      const qtyStr = h["TokenHolderQuantity"] ?? "0";
-      if (/^0x[0-9a-fA-F]{40}$/.test(addrStr)) {
-        const raw = BigInt(qtyStr || "0");
-        const balance = Number(raw) / 10 ** token.decimals;
-        whaleList.push({ address: addrStr, balance });
-      }
-    }
-    const whaleData = [];
-    if (opts.positions && whaleList.length > 0) {
-      const lendingPools = registry.getProtocolsForChain(chainName).filter(
-        (p) => p.category === ProtocolCategory.Lending && (p.interface === "aave_v3" || p.interface === "aave_v2")
-      ).filter((p) => p.contracts?.["pool"]).map((p) => ({
-        name: p.name,
-        pool: p.contracts["pool"],
-        iface: p.interface
-      }));
-      const calls = [];
-      for (const whale of whaleList) {
-        for (const { pool } of lendingPools) {
-          calls.push([
-            pool,
-            encodeFunctionData31({ abi: POOL_ABI6, functionName: "getUserAccountData", args: [whale.address] })
-          ]);
-        }
-      }
-      let results = [];
-      if (calls.length > 0) {
-        try {
-          results = await multicallRead(rpc, calls);
-        } catch {
-          results = [];
-        }
-      }
-      const poolsPerWhale = lendingPools.length;
-      for (let wi = 0; wi < whaleList.length; wi++) {
-        const whale = whaleList[wi];
-        const positions = [];
-        for (let pi = 0; pi < lendingPools.length; pi++) {
-          const { name: protoName, iface } = lendingPools[pi];
-          const idx = wi * poolsPerWhale + pi;
-          const data = results[idx] ?? null;
-          if (data && data.length >= 2 + 192 * 2) {
-            const dec = iface === "aave_v2" ? 18 : 8;
-            const divisor = 10 ** dec;
-            const collateral = Number(decodeU2564(data, 0)) / divisor;
-            const debt = Number(decodeU2564(data, 1)) / divisor;
-            const hfRaw = decodeU2564(data, 5);
-            let hf = null;
-            if (hfRaw <= BigInt("0xffffffffffffffffffffffffffffffff")) {
-              const v = Number(hfRaw) / 1e18;
-              hf = v > 1e10 ? null : round24(v);
-            }
-            if (collateral > 0.01 || debt > 0.01) {
-              positions.push({
-                protocol: protoName,
-                collateral_usd: round24(collateral),
-                debt_usd: round24(debt),
-                health_factor: hf
-              });
-            }
-          }
-        }
-        whaleData.push({
-          rank: wi + 1,
-          address: whale.address,
-          balance: round43(whale.balance),
-          positions
-        });
-      }
-    } else {
-      for (let wi = 0; wi < whaleList.length; wi++) {
-        const whale = whaleList[wi];
-        whaleData.push({
-          rank: wi + 1,
-          address: whale.address,
-          balance: round43(whale.balance)
-        });
-      }
-    }
-    printOutput(
-      {
-        chain: chain.name,
-        token: opts.token,
-        token_address: tokenAddr,
-        decimals: token.decimals,
-        top,
-        holders: whaleData,
-        explorer: chain.explorer_url ?? ""
-      },
-      mode
-    );
-  });
-}
-
 // src/commands/bridge.ts
 var LIFI_API = "https://li.quest/v1";
 var DLN_API = "https://dln.debridge.finance/v1.0/dln/order";
@@ -9845,7 +8339,11 @@ async function getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc) {
 }
 function registerBridge(parent, getOpts) {
   parent.command("bridge").description("Cross-chain bridge: move assets between chains").requiredOption("--token <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").requiredOption("--to-chain <chain>", "Destination chain name").option("--recipient <address>", "Recipient address on destination chain").option("--slippage <bps>", "Slippage in bps (LI.FI only)", "50").option("--provider <name>", "Bridge provider: lifi, debridge, cctp", "lifi").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const fromChain = registry.getChain(chainName);
     const toChain = registry.getChain(opts.toChain);
@@ -9901,11 +8399,11 @@ function registerBridge(parent, getOpts) {
         const amountUsdc = Number(BigInt(opts.amount)) / 1e6;
         const { fee, maxFeeSubunits } = await getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc);
         const recipientPadded = `0x${"0".repeat(24)}${recipient.replace("0x", "").toLowerCase()}`;
-        const { encodeFunctionData: encodeFunctionData34, parseAbi: parseAbi37 } = await import("viem");
-        const tokenMessengerAbi = parseAbi37([
+        const { encodeFunctionData: encodeFunctionData30, parseAbi: parseAbi34 } = await import("viem");
+        const tokenMessengerAbi = parseAbi34([
           "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, uint256 maxFee, uint32 minFinalityThreshold) external returns (uint64 nonce)"
         ]);
-        const data = encodeFunctionData34({
+        const data = encodeFunctionData30({
           abi: tokenMessengerAbi,
           functionName: "depositForBurn",
           args: [
@@ -10049,7 +8547,11 @@ async function liquidSwapRoute(tokenIn, tokenOut, amountIn, slippagePct) {
 function registerSwap(parent, getOpts, makeExecutor2) {
   parent.command("swap").description("Swap tokens via DEX aggregator (KyberSwap, OpenOcean, LiquidSwap)").requiredOption("--from <token>", "Input token symbol or address").requiredOption("--to <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").option("--provider <name>", "Aggregator: kyber, openocean, liquid", "kyber").option("--slippage <bps>", "Slippage tolerance in bps", "50").action(async (opts) => {
     const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
+    const chainName = parent.opts().chain;
+    if (!chainName) {
+      printOutput({ error: "--chain is required (e.g. --chain hyperevm)" }, getOpts());
+      return;
+    }
     const registry = Registry.loadEmbedded();
     const provider = opts.provider.toLowerCase();
     const slippageBps = parseInt(opts.slippage, 10);
@@ -10178,16 +8680,16 @@ function registerSwap(parent, getOpts, makeExecutor2) {
 // src/commands/setup.ts
 import pc2 from "picocolors";
 import { createInterface } from "readline";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve3 } from "path";
-var DEFI_DIR = resolve3(process.env.HOME || "~", ".defi");
-var ENV_FILE = resolve3(DEFI_DIR, ".env");
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+var DEFI_DIR = resolve4(process.env.HOME || "~", ".defi");
+var ENV_FILE = resolve4(DEFI_DIR, ".env");
 function ensureDefiDir() {
   if (!existsSync3(DEFI_DIR)) mkdirSync2(DEFI_DIR, { recursive: true, mode: 448 });
 }
 function loadEnvFile() {
   if (!existsSync3(ENV_FILE)) return {};
-  const lines = readFileSync3(ENV_FILE, "utf-8").split("\n");
+  const lines = readFileSync4(ENV_FILE, "utf-8").split("\n");
   const env = {};
   for (const line of lines) {
     const trimmed = line.trim();
@@ -10332,10 +8834,10 @@ var BANNER = `
 
   2 chains \xB7 21 protocols \xB7 by HypurrQuant
 
-  Lending, LP provision, farming, gauges, vaults,
-  yield comparison \u2014 all from your terminal.
+  Lending, LP farming, DEX swap, yield comparison
+  \u2014 all from your terminal.
 `;
-var program = new Command().name("defi").description("DeFi CLI \u2014 Multi-chain DeFi toolkit").version(_pkg.version).addHelpText("before", BANNER).option("--json", "Output as JSON").option("--ndjson", "Output as newline-delimited JSON").option("--fields <fields>", "Select specific output fields (comma-separated)").option("--chain <chain>", "Target chain", "hyperevm").option("--dry-run", "Dry-run mode (default, no broadcast)", true).option("--broadcast", "Actually broadcast the transaction");
+var program = new Command().name("defi").description("DeFi CLI \u2014 Multi-chain DeFi toolkit").version(_pkg.version).addHelpText("before", BANNER).option("--json", "Output as JSON").option("--ndjson", "Output as newline-delimited JSON").option("--fields <fields>", "Select specific output fields (comma-separated)").option("--chain <chain>", "Target chain").option("--dry-run", "Dry-run mode (default, no broadcast)", true).option("--broadcast", "Actually broadcast the transaction");
 function getOutputMode() {
   const opts = program.opts();
   return parseOutputMode(opts);
@@ -10343,38 +8845,35 @@ function getOutputMode() {
 function makeExecutor() {
   const opts = program.opts();
   const registry = Registry.loadEmbedded();
-  const chain = registry.getChain(opts.chain ?? "hyperevm");
+  if (!opts.chain) {
+    process.stderr.write("Error: --chain is required for this command (e.g. --chain hyperevm)\n");
+    process.exit(1);
+  }
+  const chain = registry.getChain(opts.chain);
   return new Executor(!!opts.broadcast, chain.effectiveRpcUrl(), chain.explorer_url);
 }
 registerStatus(program, getOutputMode);
 registerSchema(program, getOutputMode);
 registerLP(program, getOutputMode, makeExecutor);
 registerLending(program, getOutputMode, makeExecutor);
-registerCdp(program, getOutputMode, makeExecutor);
-registerVault(program, getOutputMode, makeExecutor);
 registerYield(program, getOutputMode, makeExecutor);
 registerPortfolio(program, getOutputMode);
-registerMonitor(program, getOutputMode);
-registerAlert(program, getOutputMode);
-registerScan(program, getOutputMode);
-registerPositions(program, getOutputMode);
 registerPrice(program, getOutputMode);
 registerWallet(program, getOutputMode);
 registerToken(program, getOutputMode, makeExecutor);
-registerWhales(program, getOutputMode);
 registerBridge(program, getOutputMode);
 registerSwap(program, getOutputMode, makeExecutor);
 registerSetup(program);
 
 // src/landing.ts
 import pc3 from "picocolors";
-import { encodeFunctionData as encodeFunctionData33, parseAbi as parseAbi36, formatUnits } from "viem";
+import { encodeFunctionData as encodeFunctionData29, parseAbi as parseAbi33, formatUnits } from "viem";
 var HYPEREVM_DISPLAY = ["HYPE", "WHYPE", "USDC", "USDT0", "USDe", "kHYPE", "wstHYPE"];
 var MANTLE_DISPLAY = ["MNT", "WMNT", "USDC", "USDT", "WETH", "mETH"];
-var balanceOfAbi = parseAbi36([
+var balanceOfAbi = parseAbi33([
   "function balanceOf(address account) view returns (uint256)"
 ]);
-var getEthBalanceAbi = parseAbi36([
+var getEthBalanceAbi = parseAbi33([
   "function getEthBalance(address addr) view returns (uint256)"
 ]);
 async function fetchBalances(rpcUrl, wallet, tokens) {
@@ -10383,7 +8882,7 @@ async function fetchBalances(rpcUrl, wallet, tokens) {
     if (isNative) {
       return [
         MULTICALL3_ADDRESS,
-        encodeFunctionData33({
+        encodeFunctionData29({
           abi: getEthBalanceAbi,
           functionName: "getEthBalance",
           args: [wallet]
@@ -10392,7 +8891,7 @@ async function fetchBalances(rpcUrl, wallet, tokens) {
     }
     return [
       t.address,
-      encodeFunctionData33({
+      encodeFunctionData29({
         abi: balanceOfAbi,
         functionName: "balanceOf",
         args: [wallet]
@@ -10536,7 +9035,7 @@ async function showLandingPage(isJson) {
 }
 
 // src/main.ts
-config({ path: resolve4(process.env.HOME || "~", ".defi", ".env"), quiet: true });
+config({ path: resolve5(process.env.HOME || "~", ".defi", ".env"), quiet: true });
 config({ quiet: true });
 async function main() {
   try {
@@ -10550,14 +9049,9 @@ async function main() {
       "vault",
       "yield",
       "portfolio",
-      "monitor",
-      "alert",
-      "scan",
-      "positions",
       "price",
       "wallet",
       "token",
-      "whales",
       "bridge",
       "swap",
       "agent",
@@ -10590,43 +9084,4 @@ async function main() {
   }
 }
 main();
-/*! Bundled license information:
-
-smol-toml/dist/error.js:
-smol-toml/dist/util.js:
-smol-toml/dist/date.js:
-smol-toml/dist/primitive.js:
-smol-toml/dist/extract.js:
-smol-toml/dist/struct.js:
-smol-toml/dist/parse.js:
-smol-toml/dist/stringify.js:
-smol-toml/dist/index.js:
-  (*!
-   * Copyright (c) Squirrel Chat et al., All rights reserved.
-   * SPDX-License-Identifier: BSD-3-Clause
-   *
-   * Redistribution and use in source and binary forms, with or without
-   * modification, are permitted provided that the following conditions are met:
-   *
-   * 1. Redistributions of source code must retain the above copyright notice, this
-   *    list of conditions and the following disclaimer.
-   * 2. Redistributions in binary form must reproduce the above copyright notice,
-   *    this list of conditions and the following disclaimer in the
-   *    documentation and/or other materials provided with the distribution.
-   * 3. Neither the name of the copyright holder nor the names of its contributors
-   *    may be used to endorse or promote products derived from this software without
-   *    specific prior written permission.
-   *
-   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   *)
-*/
 //# sourceMappingURL=main.js.map