polkadot-cli 1.16.0 → 1.18.0

package/dist/cli.mjs

@@ -240,6 +240,9 @@ function getMetadataPath(chainName) {
 function getMetadataFingerprintPath(chainName) {
   return join(getChainDir(chainName), "metadata.fingerprint.json");
 }
+function getRpcMethodsPath(chainName) {
+  return join(getChainDir(chainName), "rpc-methods.json");
+}
 function getConfigPath() {
   return join(getConfigDir(), "config.json");
 }
@@ -305,6 +308,31 @@ async function loadMetadataFingerprint(chainName) {
     return null;
   }
 }
+async function loadRpcMethods(chainName) {
+  const path = getRpcMethodsPath(chainName);
+  if (!await fileExists(path))
+    return null;
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf-8"));
+    if (parsed && Array.isArray(parsed.methods) && typeof parsed.version === "number" && typeof parsed.fetchedAt === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveRpcMethods(chainName, methods, version2) {
+  const dir = getChainDir(chainName);
+  await ensureDir(dir);
+  const cache = {
+    methods,
+    version: version2,
+    fetchedAt: new Date().toISOString()
+  };
+  await writeFile(getRpcMethodsPath(chainName), `${JSON.stringify(cache, null, 2)}
+`);
+}
 async function removeChainData(chainName) {
   const dir = getChainDir(chainName);
   await rm(dir, { recursive: true, force: true });
@@ -375,6 +403,15 @@ function isEnvSecret(secret) {
 function isWatchOnly(account) {
   return account.secret === undefined;
 }
+function classifyAccount(account) {
+  if (account.source?.kind === "pallet")
+    return "pallet";
+  if (account.source?.kind === "parachain")
+    return "parachain";
+  if (account.secret !== undefined)
+    return "signer";
+  return "watch-only";
+}
 
 // src/utils/fuzzy-match.ts
 function levenshtein(a, b) {
@@ -674,6 +711,11 @@ function printResult(data, format = "pretty") {
 function isJsonOutput(opts) {
   return opts.json === true || opts.output === "json";
 }
+function writeStdout(text) {
+  return new Promise((resolve) => {
+    process.stdout.write(text, () => resolve());
+  });
+}
 function printJsonLine(data) {
   console.log(JSON.stringify(data, replacer));
 }
@@ -853,6 +895,324 @@ var init_client = __esm(() => {
   init_errors();
 });
 
+// src/core/pretty-type.ts
+function visualWidth(s) {
+  return s.replace(ANSI_RE, "").length;
+}
+function paint(color, code, text) {
+  return color ? `${code}${text}${RESET2}` : text;
+}
+function defaultWidth() {
+  return process.stdout.columns ?? 80;
+}
+function resolveOpts(opts) {
+  return {
+    indent: opts.indent ?? 0,
+    prefix: opts.prefix ?? 0,
+    width: opts.width ?? defaultWidth(),
+    color: opts.color ?? isTTY
+  };
+}
+function compactEntry(entry, color) {
+  if (!entry)
+    return "";
+  switch (entry.type) {
+    case "primitive":
+      return paint(color, YELLOW2, entry.value);
+    case "compact": {
+      const inner = entry.isBig ? "u128" : "u64";
+      return `${paint(color, MAGENTA2, "Compact")}<${paint(color, YELLOW2, inner)}>`;
+    }
+    case "AccountId32":
+      return paint(color, GREEN2, "AccountId32");
+    case "bitSequence":
+      return paint(color, MAGENTA2, "BitSequence");
+    case "sequence":
+      return `${paint(color, MAGENTA2, "Vec")}<${compactEntry(entry.value, color)}>`;
+    case "array":
+      return `[${compactEntry(entry.value, color)}; ${entry.len}]`;
+    case "tuple":
+      return `(${entry.value.map((v) => compactEntry(v, color)).join(", ")})`;
+    case "struct": {
+      const fields = Object.entries(entry.value);
+      if (fields.length === 0)
+        return "{}";
+      const inner = fields.map(([k, v]) => `${paint(color, CYAN2, k)}: ${compactEntry(v, color)}`).join(", ");
+      return `{ ${inner} }`;
+    }
+    case "option":
+      return `${paint(color, MAGENTA2, "Option")}<${compactEntry(entry.value, color)}>`;
+    case "result":
+      return `${paint(color, MAGENTA2, "Result")}<${compactEntry(entry.value.ok, color)}, ${compactEntry(entry.value.ko, color)}>`;
+    case "enum": {
+      const variants = Object.keys(entry.value);
+      if (variants.length > ENUM_COMPACT_LIMIT) {
+        return `enum(${variants.length} variants)`;
+      }
+      return variants.map((v) => paint(color, GREEN2, v)).join(" | ");
+    }
+    case "void":
+      return "()";
+    case "lookupEntry":
+      return compactEntry(entry.value, color);
+    default:
+      return "unknown";
+  }
+}
+function expandEntry(entry, indent, width, color, prefix = 0) {
+  const compact = compactEntry(entry, color);
+  if (visualWidth(compact) + indent + prefix <= width)
+    return compact;
+  switch (entry.type) {
+    case "struct":
+      return expandStruct(entry.value, indent, width, color);
+    case "tuple":
+      return expandTuple(entry.value, indent, width, color);
+    case "sequence":
+      return wrapMultiline("Vec", "<", ">", entry.value, indent, width, color);
+    case "array": {
+      const inner = expandEntry(entry.value, indent + 1, width, color);
+      return `[${inner}; ${entry.len}]`;
+    }
+    case "option":
+      return wrapMultiline("Option", "<", ">", entry.value, indent, width, color);
+    case "result": {
+      const innerIndent = indent + 2;
+      const padding = " ".repeat(innerIndent);
+      const closePadding = " ".repeat(indent);
+      const ok = expandEntry(entry.value.ok, innerIndent, width, color);
+      const ko = expandEntry(entry.value.ko, innerIndent, width, color);
+      return `${paint(color, MAGENTA2, "Result")}<
+${padding}${ok},
+${padding}${ko}
+${closePadding}>`;
+    }
+    case "enum": {
+      const variants = Object.keys(entry.value);
+      if (variants.length > ENUM_COMPACT_LIMIT)
+        return `enum(${variants.length} variants)`;
+      return expandEnum(variants, indent, color);
+    }
+    case "lookupEntry":
+      return expandEntry(entry.value, indent, width, color);
+    default:
+      return compact;
+  }
+}
+function expandStruct(fields, indent, width, color) {
+  const entries = Object.entries(fields);
+  if (entries.length === 0)
+    return "{}";
+  return renderFieldList(entries, "{", "}", indent, width, color);
+}
+function expandTuple(items, indent, width, color) {
+  if (items.length === 0)
+    return "()";
+  const inner = " ".repeat(indent + 2);
+  const close = " ".repeat(indent);
+  const lines = items.map((v) => `${inner}${expandEntry(v, indent + 2, width, color)}`);
+  return `(
+${lines.join(`,
+`)},
+${close})`;
+}
+function wrapMultiline(name, open, close, inner, indent, width, color) {
+  const innerIndent = indent + 2;
+  const padding = " ".repeat(innerIndent);
+  const closePadding = " ".repeat(indent);
+  const innerStr = expandEntry(inner, innerIndent, width, color);
+  return `${paint(color, MAGENTA2, name)}${open}
+${padding}${innerStr}
+${closePadding}${close}`;
+}
+function expandEnum(variants, indent, color) {
+  const prefix = `
+${" ".repeat(indent)}| `;
+  const [first, ...rest] = variants;
+  const head = paint(color, GREEN2, first ?? "");
+  if (rest.length === 0)
+    return head;
+  const tail = rest.map((v) => paint(color, GREEN2, v)).join(prefix);
+  return `${head}${prefix}${tail}`;
+}
+function renderFieldList(fields, open, close, indent, width, color) {
+  const innerIndent = indent + 2;
+  const maxNameLen = Math.max(...fields.map(([k]) => k.length));
+  const align = maxNameLen <= ALIGN_PADDING_LIMIT;
+  const padTo = align ? maxNameLen : 0;
+  const padding = " ".repeat(innerIndent);
+  const closePadding = " ".repeat(indent);
+  const lines = fields.map(([k, v]) => {
+    const paddedName = align ? k.padEnd(padTo) : k;
+    const fieldPrefix = (align ? padTo : k.length) + 2;
+    const value = expandEntry(v, innerIndent, width, color, fieldPrefix);
+    return `${padding}${paint(color, CYAN2, paddedName)}: ${value}`;
+  });
+  return `${open}
+${lines.join(`,
+`)},
+${closePadding}${close}`;
+}
+function prettyType(entry, opts = {}) {
+  const { indent, prefix, width, color } = resolveOpts(opts);
+  const compact = compactEntry(entry, color);
+  if (visualWidth(compact) + indent + prefix <= width)
+    return compact;
+  return expandEntry(entry, indent, width, color);
+}
+function prettyTypeById(lookup, typeId, opts = {}) {
+  try {
+    const entry = lookup(typeId);
+    if (!entry || typeof entry.type !== "string")
+      return `type(${typeId})`;
+    return prettyType(entry, opts);
+  } catch {
+    return `type(${typeId})`;
+  }
+}
+function prettyCallArgs(meta, palletName, callName, opts = {}) {
+  const fields = getCallFields(meta, palletName, callName);
+  if (fields === null)
+    return "";
+  return renderArgsFromFields(fields, opts);
+}
+function prettyEventFields(meta, palletName, eventName, opts = {}) {
+  const fields = getEventFields(meta, palletName, eventName);
+  if (fields === null)
+    return "";
+  return renderArgsFromFields(fields, opts);
+}
+function prettyRuntimeApiArgs(lookup, inputs, opts = {}) {
+  if (inputs.length === 0)
+    return "()";
+  const namedFields = inputs.map((i) => {
+    let entry;
+    try {
+      entry = lookup(i.type);
+      if (!entry || typeof entry.type !== "string")
+        entry = { type: "unknown" };
+    } catch {
+      entry = { type: "unknown" };
+    }
+    return [i.name, entry];
+  });
+  return renderArgsFromFields({ kind: "named", fields: namedFields }, opts);
+}
+function unwrapVariant(variant) {
+  if (!variant)
+    return null;
+  if (variant.type === "void")
+    return { kind: "void" };
+  if (variant.type === "struct") {
+    return {
+      kind: "named",
+      fields: Object.entries(variant.value)
+    };
+  }
+  if (variant.type === "tuple") {
+    return { kind: "positional", types: variant.value };
+  }
+  if (variant.type === "lookupEntry") {
+    const inner = variant.value;
+    if (inner.type === "void")
+      return { kind: "void" };
+    if (inner.type === "struct") {
+      return {
+        kind: "named",
+        fields: Object.entries(inner.value)
+      };
+    }
+    return { kind: "single", type: inner };
+  }
+  return null;
+}
+function getCallFields(meta, palletName, callName) {
+  try {
+    const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
+    if (!palletMeta?.calls)
+      return null;
+    const callsEntry = meta.lookup(palletMeta.calls.type);
+    if (callsEntry.type !== "enum")
+      return null;
+    const variant = callsEntry.value[callName];
+    return unwrapVariant(variant);
+  } catch {
+    return null;
+  }
+}
+function getEventFields(meta, palletName, eventName) {
+  try {
+    const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
+    if (!palletMeta?.events)
+      return null;
+    const eventsEntry = meta.lookup(palletMeta.events.type);
+    if (eventsEntry.type !== "enum")
+      return null;
+    const variant = eventsEntry.value[eventName];
+    return unwrapVariant(variant);
+  } catch {
+    return null;
+  }
+}
+function renderArgsFromFields(fields, opts) {
+  const { indent, prefix, width, color } = resolveOpts(opts);
+  const lead = indent + prefix;
+  switch (fields.kind) {
+    case "void":
+      return "()";
+    case "named": {
+      const compact = `(${fields.fields.map(([k, v]) => `${paint(color, CYAN2, k)}: ${compactEntry(v, color)}`).join(", ")})`;
+      if (visualWidth(compact) + lead <= width)
+        return compact;
+      return renderFieldList(fields.fields, "(", ")", indent, width, color);
+    }
+    case "positional": {
+      const compact = `(${fields.types.map((t) => compactEntry(t, color)).join(", ")})`;
+      if (visualWidth(compact) + lead <= width)
+        return compact;
+      const innerIndent = indent + 2;
+      const padding = " ".repeat(innerIndent);
+      const closePadding = " ".repeat(indent);
+      const lines = fields.types.map((t) => `${padding}${expandEntry(t, innerIndent, width, color)}`);
+      return `(
+${lines.join(`,
+`)},
+${closePadding})`;
+    }
+    case "single": {
+      const compact = `(${compactEntry(fields.type, color)})`;
+      if (visualWidth(compact) + lead <= width)
+        return compact;
+      const inner = expandEntry(fields.type, indent + 2, width, color);
+      return `(
+${" ".repeat(indent + 2)}${inner},
+${" ".repeat(indent)})`;
+    }
+  }
+}
+function compactTypeString(entry) {
+  return compactEntry(entry, false);
+}
+function compactArgsString(fields) {
+  if (fields === null)
+    return "";
+  switch (fields.kind) {
+    case "void":
+      return "()";
+    case "named":
+      return `(${fields.fields.map(([k, v]) => `${k}: ${compactEntry(v, false)}`).join(", ")})`;
+    case "positional":
+      return `(${fields.types.map((t) => compactEntry(t, false)).join(", ")})`;
+    case "single":
+      return `(${compactEntry(fields.type, false)})`;
+  }
+}
+var RESET2 = "\x1B[0m", CYAN2 = "\x1B[36m", GREEN2 = "\x1B[32m", YELLOW2 = "\x1B[33m", MAGENTA2 = "\x1B[35m", ANSI_RE, ENUM_COMPACT_LIMIT = 24, ALIGN_PADDING_LIMIT = 16;
+var init_pretty_type = __esm(() => {
+  init_output();
+  ANSI_RE = /\x1b\[[0-9;]*m/g;
+});
+
 // src/core/metadata.ts
 import { getDynamicBuilder, getLookupFn } from "@polkadot-api/metadata-builders";
 import {
@@ -1067,114 +1427,18 @@ function describeRuntimeApiMethodArgs(meta, method) {
 function describeType(lookup, typeId) {
   try {
     const entry = lookup(typeId);
-    return formatLookupEntry(entry);
+    if (!entry || typeof entry.type !== "string")
+      return `type(${typeId})`;
+    return compactTypeString(entry);
   } catch {
     return `type(${typeId})`;
   }
 }
-function formatLookupEntry(entry) {
-  switch (entry.type) {
-    case "primitive":
-      return entry.value;
-    case "compact":
-      return `Compact<${formatLookupEntry(entry.isBig ? { type: "primitive", value: "u128" } : { type: "primitive", value: "u64" })}>`;
-    case "AccountId32":
-      return "AccountId32";
-    case "bitSequence":
-      return "BitSequence";
-    case "sequence":
-      return `Vec<${formatLookupEntry(entry.value)}>`;
-    case "array":
-      return `[${formatLookupEntry(entry.value)}; ${entry.len}]`;
-    case "tuple":
-      return `(${entry.value.map(formatLookupEntry).join(", ")})`;
-    case "struct":
-      return `{ ${Object.entries(entry.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ")} }`;
-    case "option":
-      return `Option<${formatLookupEntry(entry.value)}>`;
-    case "result":
-      return `Result<${formatLookupEntry(entry.value.ok)}, ${formatLookupEntry(entry.value.ko)}>`;
-    case "enum": {
-      const variants = Object.keys(entry.value);
-      if (variants.length <= 4)
-        return variants.join(" | ");
-      return `enum(${variants.length} variants)`;
-    }
-    default:
-      return "unknown";
-  }
-}
 function describeCallArgs(meta, palletName, callName) {
-  try {
-    const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
-    if (!palletMeta?.calls)
-      return "";
-    const callsEntry = meta.lookup(palletMeta.calls.type);
-    if (callsEntry.type !== "enum")
-      return "";
-    const variant = callsEntry.value[callName];
-    if (!variant)
-      return "";
-    if (variant.type === "void")
-      return "()";
-    if (variant.type === "struct") {
-      const fields = Object.entries(variant.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ");
-      return `(${fields})`;
-    }
-    if (variant.type === "lookupEntry") {
-      const inner = variant.value;
-      if (inner.type === "void")
-        return "()";
-      if (inner.type === "struct") {
-        const fields = Object.entries(inner.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ");
-        return `(${fields})`;
-      }
-      return `(${formatLookupEntry(inner)})`;
-    }
-    if (variant.type === "tuple") {
-      const types = variant.value.map(formatLookupEntry).join(", ");
-      return `(${types})`;
-    }
-    return "";
-  } catch {
-    return "";
-  }
+  return compactArgsString(getCallFields(meta, palletName, callName));
 }
 function describeEventFields(meta, palletName, eventName) {
-  try {
-    const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
-    if (!palletMeta?.events)
-      return "";
-    const eventsEntry = meta.lookup(palletMeta.events.type);
-    if (eventsEntry.type !== "enum")
-      return "";
-    const variant = eventsEntry.value[eventName];
-    if (!variant)
-      return "";
-    if (variant.type === "void")
-      return "()";
-    if (variant.type === "struct") {
-      const fields = Object.entries(variant.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ");
-      return `(${fields})`;
-    }
-    if (variant.type === "lookupEntry") {
-      const inner = variant.value;
-      if (inner.type === "void")
-        return "()";
-      if (inner.type === "struct") {
-        const fields = Object.entries(inner.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ");
-        return `(${fields})`;
-      }
-      return `(${formatLookupEntry(inner)})`;
-    }
-    if (variant.type === "tuple") {
-      const types = variant.value.map(formatLookupEntry).join(", ");
-      return `(${types})`;
-    }
-    return "";
-  } catch {
-    return "";
-  }
+  return compactArgsString(getEventFields(meta, palletName, eventName));
 }
 function hexToBytes(hex) {
   const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -1188,6 +1452,7 @@ var METADATA_TIMEOUT_MS = 15000, optionalOpaqueBytes, v15Arg, PAPI_BUILTIN_EXTEN
 var init_metadata = __esm(() => {
   init_store();
   init_errors();
+  init_pretty_type();
   optionalOpaqueBytes = Option(Bytes());
   v15Arg = toHex(u32.enc(15));
   PAPI_BUILTIN_EXTENSIONS = new Set([
@@ -1584,6 +1849,7 @@ var init_tx = __esm(() => {
   init_client();
   init_metadata();
   init_output();
+  init_pretty_type();
   init_resolve_address();
   init_binary_display();
   init_errors();
@@ -1799,8 +2065,11 @@ async function handleCalls(target, opts) {
     }
     printHeading(`${pallet.name} Calls`);
     for (const c of pallet.calls) {
-      const args2 = describeCallArgs(meta, pallet.name, c.name);
-      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${args2}${RESET}`);
+      const args2 = prettyCallArgs(meta, pallet.name, c.name, {
+        indent: 2,
+        prefix: c.name.length
+      });
+      console.log(`  ${CYAN}${c.name}${RESET}${args2}`);
       const summary = firstSentence(c.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -1826,7 +2095,10 @@ async function handleCalls(target, opts) {
     return;
   }
   printHeading(`${pallet.name}.${callItem.name} (Call)`);
-  const args = describeCallArgs(meta, pallet.name, callItem.name);
+  const args = prettyCallArgs(meta, pallet.name, callItem.name, {
+    indent: 2,
+    prefix: 6
+  });
   console.log(`  ${BOLD}Args:${RESET} ${args}`);
   if (callItem.docs.length) {
     console.log();
@@ -1885,8 +2157,11 @@ async function handleEvents(target, opts) {
     }
     printHeading(`${pallet.name} Events`);
     for (const e of pallet.events) {
-      const fields2 = describeEventFields(meta, pallet.name, e.name);
-      console.log(`  ${CYAN}${e.name}${RESET}${DIM}${fields2}${RESET}`);
+      const fields2 = prettyEventFields(meta, pallet.name, e.name, {
+        indent: 2,
+        prefix: e.name.length
+      });
+      console.log(`  ${CYAN}${e.name}${RESET}${fields2}`);
       const summary = firstSentence(e.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -1912,7 +2187,10 @@ async function handleEvents(target, opts) {
     return;
   }
   printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-  const fields = describeEventFields(meta, pallet.name, eventItem.name);
+  const fields = prettyEventFields(meta, pallet.name, eventItem.name, {
+    indent: 2,
+    prefix: 8
+  });
   console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
   if (eventItem.docs.length) {
     console.log();
@@ -2039,24 +2317,30 @@ async function handleStorage(target, opts) {
         chain: chainName,
         pallet: pallet.name,
         storage: pallet.storage.map((s) => {
-          const valueType = describeType(meta.lookup, s.valueTypeId);
+          const valueType2 = describeType(meta.lookup, s.valueTypeId);
           const keyType = s.keyTypeId != null ? describeType(meta.lookup, s.keyTypeId) : undefined;
-          return { name: s.name, type: s.type, valueType, keyType, docs: firstSentence(s.docs) };
+          return { name: s.name, type: s.type, valueType: valueType2, keyType, docs: firstSentence(s.docs) };
         })
       }));
       return;
     }
     printHeading(`${pallet.name} Storage`);
     for (const s of pallet.storage) {
-      const valueType = describeType(meta.lookup, s.valueTypeId);
-      let typeSuffix;
-      if (s.keyTypeId != null) {
-        const keyType = describeType(meta.lookup, s.keyTypeId);
-        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
-      } else {
-        typeSuffix = `: ${valueType}`;
+      const isMap = s.keyTypeId != null;
+      const tag = isMap ? `${DIM} [map]${RESET}` : "";
+      console.log(`  ${CYAN}${s.name}${RESET}${tag}`);
+      if (isMap) {
+        const keyType = prettyTypeById(meta.lookup, s.keyTypeId, {
+          indent: 4,
+          prefix: 5
+        });
+        console.log(`    ${DIM}Key:${RESET}   ${keyType}`);
       }
-      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const valueType2 = prettyTypeById(meta.lookup, s.valueTypeId, {
+        indent: 4,
+        prefix: 7
+      });
+      console.log(`    ${DIM}Value:${RESET} ${valueType2}`);
       const summary = firstSentence(s.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -2071,7 +2355,7 @@ async function handleStorage(target, opts) {
     throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
   }
   if (isJsonOutput(opts)) {
-    const valueType = describeType(meta.lookup, storageItem.valueTypeId);
+    const valueType2 = describeType(meta.lookup, storageItem.valueTypeId);
     const keyType = storageItem.keyTypeId != null ? describeType(meta.lookup, storageItem.keyTypeId) : undefined;
     console.log(formatJson({
       chain: chainName,
@@ -2079,18 +2363,26 @@ async function handleStorage(target, opts) {
       item: storageItem.name,
       category: "storage",
       type: storageItem.type,
-      valueType,
+      valueType: valueType2,
       keyType,
       docs: storageItem.docs
     }));
     return;
   }
   printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-  console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-  console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+  console.log(`  ${BOLD}Type:${RESET}  ${storageItem.type}`);
   if (storageItem.keyTypeId != null) {
-    console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+    const keyType = prettyTypeById(meta.lookup, storageItem.keyTypeId, {
+      indent: 2,
+      prefix: 7
+    });
+    console.log(`  ${BOLD}Key:${RESET}   ${keyType}`);
   }
+  const valueType = prettyTypeById(meta.lookup, storageItem.valueTypeId, {
+    indent: 2,
+    prefix: 7
+  });
+  console.log(`  ${BOLD}Value:${RESET} ${valueType}`);
   if (storageItem.docs.length) {
     console.log();
     printDocs(storageItem.docs);
@@ -2121,9 +2413,15 @@ async function showItemHelp(category, target, opts) {
       throw new Error(suggestMessage(`method in ${api.name}`, methodName, names));
     }
     printHeading(`${api.name}.${method.name} (Runtime API)`);
-    const argStr = describeRuntimeApiMethodArgs(meta, method);
-    const retStr = describeType(meta.lookup, method.output);
-    console.log(`  ${BOLD}Args:${RESET} ${argStr}`);
+    const argStr = prettyRuntimeApiArgs(meta.lookup, method.inputs, {
+      indent: 2,
+      prefix: 9
+    });
+    const retStr = prettyTypeById(meta.lookup, method.output, {
+      indent: 2,
+      prefix: 9
+    });
+    console.log(`  ${BOLD}Args:${RESET}    ${argStr}`);
     console.log(`  ${BOLD}Returns:${RESET} ${retStr}`);
     if (method.docs.length) {
       console.log();
@@ -2166,7 +2464,10 @@ async function showItemHelp(category, target, opts) {
         throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${callItem.name} (Call)`);
-      const args = describeCallArgs(meta, pallet.name, callItem.name);
+      const args = prettyCallArgs(meta, pallet.name, callItem.name, {
+        indent: 2,
+        prefix: 6
+      });
       console.log(`  ${BOLD}Args:${RESET} ${args}`);
       if (callItem.docs.length) {
         console.log();
@@ -2193,11 +2494,19 @@ async function showItemHelp(category, target, opts) {
         throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      console.log(`  ${BOLD}Type:${RESET}  ${storageItem.type}`);
       if (storageItem.keyTypeId != null) {
-        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+        const keyType = prettyTypeById(meta.lookup, storageItem.keyTypeId, {
+          indent: 2,
+          prefix: 7
+        });
+        console.log(`  ${BOLD}Key:${RESET}   ${keyType}`);
       }
+      const valueType = prettyTypeById(meta.lookup, storageItem.valueTypeId, {
+        indent: 2,
+        prefix: 7
+      });
+      console.log(`  ${BOLD}Value:${RESET} ${valueType}`);
       if (storageItem.docs.length) {
         console.log();
         printDocs(storageItem.docs);
@@ -2224,7 +2533,11 @@ async function showItemHelp(category, target, opts) {
         throw new Error(suggestMessage(`constant in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${constItem.name} (Constant)`);
-      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constItem.typeId)}`);
+      const constType = prettyTypeById(meta.lookup, constItem.typeId, {
+        indent: 2,
+        prefix: 6
+      });
+      console.log(`  ${BOLD}Type:${RESET} ${constType}`);
       if (constItem.docs.length) {
         console.log();
         printDocs(constItem.docs);
@@ -2242,7 +2555,10 @@ async function showItemHelp(category, target, opts) {
         throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-      const fields = describeEventFields(meta, pallet.name, eventItem.name);
+      const fields = prettyEventFields(meta, pallet.name, eventItem.name, {
+        indent: 2,
+        prefix: 8
+      });
       console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
       if (eventItem.docs.length) {
         console.log();
@@ -2277,6 +2593,478 @@ var init_focused_inspect = __esm(() => {
   init_client();
   init_metadata();
   init_output();
+  init_pretty_type();
+});
+
+// src/data/rpc-registry.ts
+function inferFamily(method) {
+  const prefix = method.split("_")[0];
+  switch (prefix) {
+    case "system":
+    case "chain":
+    case "state":
+    case "author":
+    case "payment":
+    case "babe":
+    case "grandpa":
+    case "beefy":
+    case "mmr":
+    case "offchain":
+    case "dev":
+      return prefix;
+    case "rpc":
+      return "spec";
+    case "chainHead":
+      return "chainHead";
+    case "chainSpec":
+      return "chainSpec";
+    case "transaction":
+      return "transaction";
+    case "archive":
+      return "archive";
+    default:
+      return "other";
+  }
+}
+var RPC_REGISTRY;
+var init_rpc_registry = __esm(() => {
+  RPC_REGISTRY = {
+    system_health: {
+      description: "Node sync state (peers, isSyncing, shouldHavePeers).",
+      family: "system",
+      args: []
+    },
+    system_syncState: {
+      description: "Block-level sync progress (startingBlock, currentBlock, highestBlock).",
+      family: "system",
+      args: []
+    },
+    system_version: {
+      description: "Node software version string.",
+      family: "system",
+      args: []
+    },
+    system_name: {
+      description: "Node implementation name.",
+      family: "system",
+      args: []
+    },
+    system_chain: {
+      description: "Chain name as reported by the node.",
+      family: "system",
+      args: []
+    },
+    system_chainType: {
+      description: "Chain type (Live, Development, Local).",
+      family: "system",
+      args: []
+    },
+    system_properties: {
+      description: "Chain properties (ss58Format, tokenDecimals, tokenSymbol).",
+      family: "system",
+      args: []
+    },
+    system_peers: {
+      description: "Connected peer details (peerId, roles, bestHash, bestNumber).",
+      family: "system",
+      args: []
+    },
+    system_localPeerId: {
+      description: "Base58 PeerId of this node.",
+      family: "system",
+      args: []
+    },
+    system_localListenAddresses: {
+      description: "Multiaddrs this node listens on.",
+      family: "system",
+      args: []
+    },
+    system_nodeRoles: {
+      description: "Role(s) of the node (Authority, Full, Light, …).",
+      family: "system",
+      args: []
+    },
+    system_addLogFilter: {
+      description: "Add a tracing/log filter directive at runtime.",
+      family: "system",
+      args: [{ name: "directives", type: "string" }],
+      dangerous: true
+    },
+    system_resetLogFilter: {
+      description: "Reset log filter to the default set at startup.",
+      family: "system",
+      args: [],
+      dangerous: true
+    },
+    system_accountNextIndex: {
+      description: "Next nonce for an account, including pending mempool extrinsics.",
+      family: "system",
+      args: [{ name: "address", type: "AccountId" }]
+    },
+    system_dryRun: {
+      description: "Dry-run an extrinsic, returning its ApplyExtrinsicResult.",
+      family: "system",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    chain_getBlock: {
+      description: "Full block (header + extrinsics) by hash.",
+      family: "chain",
+      args: [{ name: "blockHash", type: "H256", optional: true, description: "latest if omitted" }]
+    },
+    chain_getBlockHash: {
+      description: "Block hash by number, or latest if omitted.",
+      family: "chain",
+      args: [{ name: "blockNumber", type: "u32", optional: true }]
+    },
+    chain_getFinalizedHead: {
+      description: "Hash of the latest finalized head.",
+      family: "chain",
+      args: []
+    },
+    chain_getHeader: {
+      description: "Block header by hash, or latest if omitted.",
+      family: "chain",
+      args: [{ name: "blockHash", type: "H256", optional: true }]
+    },
+    chain_subscribeAllHeads: {
+      description: "Subscribe to all imported headers.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    chain_subscribeFinalizedHeads: {
+      description: "Subscribe to finalized-head changes.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    chain_subscribeNewHeads: {
+      description: "Subscribe to best-block-head changes.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    state_call: {
+      description: "Invoke a runtime API method by name with raw SCALE-encoded arguments.",
+      family: "state",
+      args: [
+        { name: "method", type: "string", description: "e.g. Core_version" },
+        { name: "data", type: "hex", description: "SCALE-encoded args (0x for none)" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getMetadata: {
+      description: "Raw SCALE-encoded runtime metadata at a block.",
+      family: "state",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    state_getRuntimeVersion: {
+      description: "Runtime version at a block.",
+      family: "state",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    state_getStorage: {
+      description: "Raw SCALE-encoded storage value at a key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getStorageHash: {
+      description: "Blake2 hash of the value at a storage key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getStorageSize: {
+      description: "Byte length of the value at a storage key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getKeysPaged: {
+      description: "Paginated key iteration under a prefix.",
+      family: "state",
+      args: [
+        { name: "prefix", type: "StorageKey" },
+        { name: "count", type: "u32" },
+        { name: "startKey", type: "StorageKey", optional: true },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_queryStorageAt: {
+      description: "Read multiple keys at a single block.",
+      family: "state",
+      args: [
+        { name: "keys", type: "StorageKey[]" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_traceBlock: {
+      description: "Per-block storage access trace (heavy: archival/debug nodes only).",
+      family: "state",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "targets", type: "string", optional: true },
+        { name: "storageKeys", type: "string", optional: true },
+        { name: "methods", type: "string", optional: true }
+      ]
+    },
+    state_subscribeRuntimeVersion: {
+      description: "Subscribe to runtime upgrades.",
+      family: "state",
+      args: [],
+      subscription: true
+    },
+    state_subscribeStorage: {
+      description: "Subscribe to changes for a set of keys.",
+      family: "state",
+      args: [{ name: "keys", type: "StorageKey[]" }],
+      subscription: true
+    },
+    author_pendingExtrinsics: {
+      description: "Mempool snapshot — encoded extrinsics waiting to be included.",
+      family: "author",
+      args: []
+    },
+    author_submitExtrinsic: {
+      description: "Submit a signed extrinsic to the mempool. Returns the tx hash.",
+      family: "author",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true
+    },
+    author_removeExtrinsic: {
+      description: "Remove specific extrinsics from the mempool by hash.",
+      family: "author",
+      args: [{ name: "bytesOrHash", type: "ExtrinsicOrHash[]" }],
+      dangerous: true
+    },
+    author_hasKey: {
+      description: "Whether the keystore has the public key for a given key type.",
+      family: "author",
+      args: [
+        { name: "publicKey", type: "hex" },
+        { name: "keyType", type: "string", description: "e.g. babe, gran, imon" }
+      ]
+    },
+    author_hasSessionKeys: {
+      description: "Whether the keystore has all keys for a session-keys blob.",
+      family: "author",
+      args: [{ name: "sessionKeys", type: "hex" }]
+    },
+    author_rotateKeys: {
+      description: "Generate a new set of session keys and return the public-keys blob.",
+      family: "author",
+      args: [],
+      dangerous: true
+    },
+    author_insertKey: {
+      description: "Insert a key into the node keystore.",
+      family: "author",
+      args: [
+        { name: "keyType", type: "string" },
+        { name: "suri", type: "string" },
+        { name: "publicKey", type: "hex" }
+      ],
+      dangerous: true
+    },
+    author_submitAndWatchExtrinsic: {
+      description: "Submit an extrinsic and subscribe to its status updates.",
+      family: "author",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true,
+      subscription: true
+    },
+    payment_queryInfo: {
+      description: "Pre-submission fee estimate (weight, partialFee, class).",
+      family: "payment",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    payment_queryFeeDetails: {
+      description: "Fee breakdown (baseFee, lenFee, adjustedWeightFee, tip).",
+      family: "payment",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    babe_epochAuthorship: {
+      description: "Slots this node is allowed to author in the current epoch.",
+      family: "babe",
+      args: []
+    },
+    grandpa_proveFinality: {
+      description: "Finality proof up to a block (for light clients).",
+      family: "grandpa",
+      args: [{ name: "blockNumber", type: "u32" }]
+    },
+    grandpa_roundState: {
+      description: "GRANDPA round state (best round, total weight, voters).",
+      family: "grandpa",
+      args: []
+    },
+    grandpa_subscribeJustifications: {
+      description: "Subscribe to GRANDPA justifications.",
+      family: "grandpa",
+      args: [],
+      subscription: true
+    },
+    beefy_getFinalizedHead: {
+      description: "Latest BEEFY-finalized block hash.",
+      family: "beefy",
+      args: []
+    },
+    beefy_subscribeJustifications: {
+      description: "Subscribe to BEEFY signed commitments.",
+      family: "beefy",
+      args: [],
+      subscription: true
+    },
+    mmr_root: {
+      description: "MMR root at a block.",
+      family: "mmr",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    mmr_generateProof: {
+      description: "Generate an MMR proof for given leaf indices.",
+      family: "mmr",
+      args: [
+        { name: "blockNumbers", type: "u32[]" },
+        { name: "bestKnownBlockNumber", type: "u32", optional: true },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    mmr_verifyProof: {
+      description: "Verify an MMR proof.",
+      family: "mmr",
+      args: [{ name: "proof", type: "MmrLeavesProof" }]
+    },
+    offchain_localStorageGet: {
+      description: "Read from offchain-worker local storage (PERSISTENT or LOCAL kind).",
+      family: "offchain",
+      args: [
+        { name: "kind", type: "string", description: "PERSISTENT or LOCAL" },
+        { name: "key", type: "hex" }
+      ]
+    },
+    offchain_localStorageSet: {
+      description: "Write to offchain-worker local storage.",
+      family: "offchain",
+      args: [
+        { name: "kind", type: "string" },
+        { name: "key", type: "hex" },
+        { name: "value", type: "hex" }
+      ],
+      dangerous: true
+    },
+    dev_newBlock: {
+      description: "Manually trigger block production (manual-seal dev nodes).",
+      family: "dev",
+      args: [
+        {
+          name: "params",
+          type: "json",
+          optional: true,
+          description: "{ create_empty?: bool, finalize?: bool }"
+        }
+      ],
+      dangerous: true
+    },
+    dev_setHead: {
+      description: "Set the chain head to a specific block (manual-seal dev nodes).",
+      family: "dev",
+      args: [{ name: "blockHash", type: "H256" }],
+      dangerous: true
+    },
+    rpc_methods: {
+      description: "List of JSON-RPC methods this node exposes.",
+      family: "spec",
+      args: []
+    },
+    chainSpec_v1_chainName: {
+      description: "Chain name from the chain spec (no SCALE).",
+      family: "chainSpec",
+      args: []
+    },
+    chainSpec_v1_genesisHash: {
+      description: "Genesis block hash.",
+      family: "chainSpec",
+      args: []
+    },
+    chainSpec_v1_properties: {
+      description: "Chain properties from the chain spec.",
+      family: "chainSpec",
+      args: []
+    },
+    archive_v1_finalizedHeight: {
+      description: "Latest finalized block number this archive node has.",
+      family: "archive",
+      args: []
+    },
+    archive_v1_genesisHash: {
+      description: "Genesis block hash from the archive node.",
+      family: "archive",
+      args: []
+    },
+    archive_v1_hashByHeight: {
+      description: "Block hashes at a height (canonical + forks).",
+      family: "archive",
+      args: [{ name: "height", type: "u32" }]
+    },
+    archive_v1_header: {
+      description: "Header for an archived block.",
+      family: "archive",
+      args: [{ name: "blockHash", type: "H256" }]
+    },
+    archive_v1_body: {
+      description: "Block body (extrinsics) for an archived block.",
+      family: "archive",
+      args: [{ name: "blockHash", type: "H256" }]
+    },
+    archive_v1_call: {
+      description: "Invoke a runtime API at an archived block.",
+      family: "archive",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "function", type: "string" },
+        { name: "callParameters", type: "hex" }
+      ]
+    },
+    archive_v1_storage: {
+      description: "Read storage at an archived block.",
+      family: "archive",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "items", type: "StorageItemInput[]" },
+        { name: "childTrie", type: "string", optional: true }
+      ],
+      subscription: true
+    },
+    chainHead_v1_follow: {
+      description: "Pin chainHead and stream block events. Requires a follow session.",
+      family: "chainHead",
+      args: [{ name: "withRuntime", type: "bool" }],
+      subscription: true
+    },
+    transaction_v1_broadcast: {
+      description: "Broadcast a signed extrinsic and watch its status.",
+      family: "transaction",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true,
+      subscription: true
+    }
+  };
 });
 
 // src/core/hash.ts
@@ -2462,11 +3250,8 @@ async function generateCompletions(currentWord, precedingWords) {
   if (firstArg === "hash") {
     return filterPrefix(getAlgorithmNames(), currentWord);
   }
-  if (firstArg === "parachain") {
-    if (prevWord === "--type") {
-      return filterPrefix(["child", "sibling"], currentWord);
-    }
-    return [];
+  if (firstArg === "account" && prevWord === "--parachain-type") {
+    return filterPrefix(["child", "sibling"], currentWord);
   }
   return completeDotpath(currentWord, config, knownChains, precedingWords);
 }
@@ -2509,6 +3294,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
     if (category === "extensions") {
       return completeExtensionsCategory(first, numComplete, endsWithDot, currentWord, config, chainFromFlag);
     }
+    if (category === "rpc") {
+      return completeRpcCategory(first, numComplete, endsWithDot, currentWord, chainFromFlag);
+    }
     if (numComplete === 1 && endsWithDot) {
       const chainName = chainFromFlag;
       if (!chainName)
@@ -2568,6 +3356,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
       if (category === "extensions") {
         return completeExtensionsCategory(`${first}.${completeSegments[1]}`, numComplete - 1, endsWithDot, currentWord, config, chainName);
       }
+      if (category === "rpc") {
+        return completeRpcCategory(`${first}.${completeSegments[1]}`, numComplete - 1, endsWithDot, currentWord, chainName);
+      }
       const pallets = await loadPallets(config, chainName);
       if (!pallets)
         return [];
@@ -2641,6 +3432,24 @@ async function completeExtensionsCategory(prefix, numComplete, endsWithDot, curr
   }
   return [];
 }
+async function completeRpcCategory(prefix, numComplete, endsWithDot, currentWord, chainNameOverride) {
+  let names;
+  if (chainNameOverride) {
+    const cached = await loadRpcMethods(chainNameOverride);
+    names = cached?.methods ?? Object.keys(RPC_REGISTRY);
+  } else {
+    names = Object.keys(RPC_REGISTRY);
+  }
+  if (numComplete === 1 && endsWithDot) {
+    const candidates = names.map((n) => `${prefix}.${n}`);
+    return filterPrefix(candidates, currentWord.slice(0, -1));
+  }
+  if (numComplete === 1 && !endsWithDot) {
+    const candidates = names.map((n) => `${prefix}.${n}`);
+    return filterPrefix(candidates, currentWord);
+  }
+  return [];
+}
 var CATEGORIES2, CATEGORY_ALIASES2, NAMED_COMMANDS, CHAIN_SUBCOMMANDS, ACCOUNT_SUBCOMMANDS, GLOBAL_OPTIONS, TX_OPTIONS, QUERY_OPTIONS;
 var init_complete = __esm(() => {
   init_accounts_store();
@@ -2648,7 +3457,17 @@ var init_complete = __esm(() => {
   init_accounts();
   init_hash();
   init_metadata();
-  CATEGORIES2 = ["query", "tx", "const", "events", "errors", "apis", "extensions"];
+  init_rpc_registry();
+  CATEGORIES2 = [
+    "query",
+    "tx",
+    "const",
+    "events",
+    "errors",
+    "apis",
+    "extensions",
+    "rpc"
+  ];
   CATEGORY_ALIASES2 = {
     query: "query",
     tx: "tx",
@@ -2663,10 +3482,11 @@ var init_complete = __esm(() => {
     api: "apis",
     extensions: "extensions",
     extension: "extensions",
-    ext: "extensions"
+    ext: "extensions",
+    rpc: "rpc"
   };
-  NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "parachain", "completions"];
-  CHAIN_SUBCOMMANDS = ["add", "remove", "update", "list"];
+  NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "completions"];
+  CHAIN_SUBCOMMANDS = ["add", "info", "list", "remove", "update"];
   ACCOUNT_SUBCOMMANDS = [
     "add",
     "create",
@@ -2697,23 +3517,94 @@ var init_complete = __esm(() => {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "1.16.0";
+var version = "1.18.0";
 
 // src/commands/account.ts
 init_accounts_store();
 init_accounts();
 init_output();
 import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+
+// src/core/pallet.ts
+init_errors();
+var MODL_PREFIX = new Uint8Array([109, 111, 100, 108]);
+var PALLET_ID_BYTES = 8;
+function derivePalletAccount(palletId) {
+  if (palletId.length !== PALLET_ID_BYTES) {
+    throw new CliError(`PalletId must be exactly ${PALLET_ID_BYTES} bytes (got ${palletId.length}).`);
+  }
+  const result = new Uint8Array(32);
+  result.set(MODL_PREFIX, 0);
+  result.set(palletId, 4);
+  return result;
+}
+function parsePalletId(input) {
+  if (input.startsWith("0x") || input.startsWith("0X")) {
+    const hex = input.slice(2);
+    if (hex.length !== PALLET_ID_BYTES * 2) {
+      throw new CliError(`Invalid PalletId hex "${input}". Must be 0x followed by exactly ${PALLET_ID_BYTES * 2} hex characters.`);
+    }
+    if (!/^[0-9a-fA-F]+$/.test(hex)) {
+      throw new CliError(`Invalid PalletId hex "${input}". Contains non-hex characters.`);
+    }
+    const bytes2 = new Uint8Array(PALLET_ID_BYTES);
+    for (let i = 0;i < PALLET_ID_BYTES; i++) {
+      bytes2[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes2;
+  }
+  if (input.length !== PALLET_ID_BYTES) {
+    throw new CliError(`Invalid PalletId "${input}". Must be ${PALLET_ID_BYTES} ASCII characters or 0x-prefixed hex.`);
+  }
+  const bytes = new Uint8Array(PALLET_ID_BYTES);
+  for (let i = 0;i < PALLET_ID_BYTES; i++) {
+    const code = input.charCodeAt(i);
+    if (code > 127) {
+      throw new CliError(`Invalid PalletId "${input}". ASCII form must contain only ASCII bytes.`);
+    }
+    bytes[i] = code;
+  }
+  return bytes;
+}
+function formatPalletId(palletId) {
+  const allPrintable = palletId.every((b) => b >= 32 && b <= 126);
+  if (allPrintable) {
+    return Array.from(palletId, (b) => String.fromCharCode(b)).join("");
+  }
+  return `0x${Array.from(palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/core/parachain.ts
+var SOVEREIGN_ACCOUNT_TYPES = ["child", "sibling"];
+var PREFIXES = {
+  child: new Uint8Array([112, 97, 114, 97]),
+  sibling: new Uint8Array([115, 105, 98, 108])
+};
+function deriveSovereignAccount(paraId, type) {
+  const result = new Uint8Array(32);
+  result.set(PREFIXES[type], 0);
+  new DataView(result.buffer).setUint32(4, paraId, true);
+  return result;
+}
+function isValidParaId(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+
+// src/commands/account.ts
 var ACCOUNT_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot account add <name> <ss58|hex>                                Add a watch-only address (no secret)
   $ dot account add <name> --secret <s> [--path <derivation>]        Import from BIP39 mnemonic
   $ dot account add <name> --env <VAR> [--path <derivation>]         Import account backed by env variable
+  $ dot account add <name> --parachain <id> --parachain-type <t>     Derive a parachain sovereign (t = child|sibling)
+  $ dot account add <name> --pallet-id <8 chars or 0x hex>           Derive a pallet sovereign (e.g. py/trsry)
   $ dot account create|new <name> [--path <derivation>]              Create a new account
   $ dot account import <file>                                        Batch-import accounts from a file
   $ dot account export [names...]                                    Export accounts to stdout
   $ dot account derive <source> <new-name> --path <derivation>       Derive a child account
   $ dot account inspect <input> [--prefix <N>] [--show-secret]       Inspect an account/address/key
+  $ dot account inspect --pallet-id <id> [--prefix <N>]              Derive a pallet sovereign (no save — script-friendly)
+  $ dot account inspect --parachain <id> --parachain-type <t>        Derive a parachain sovereign (no save — script-friendly)
   $ dot account list                                                 List all accounts
   $ dot account remove|delete <name> [name2] ...                     Remove stored account(s)
 
@@ -2721,6 +3612,10 @@ ${BOLD}Examples:${RESET}
   $ dot account add treasury 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
   $ dot account add treasury --secret "word1 word2 ... word12"
   $ dot account add ci-signer --env MY_SECRET --path //ci
+  $ dot account add Treasury --pallet-id py/trsry
+  $ dot account add Bounties --pallet-id 0x70792f626f756e74
+  $ dot account add People --parachain 1004 --parachain-type child
+  $ dot account add People-Sibling --parachain 1004 --parachain-type sibling
   $ dot account create my-validator
   $ dot account create my-staking --path //staking
   $ dot account create multi --path //polkadot//0/wallet
@@ -2736,6 +3631,8 @@ ${BOLD}Examples:${RESET}
   $ dot account inspect dave --show-secret
   $ dot account inspect 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
   $ dot account inspect 0xd435...a27d --prefix 0
+  $ dot account inspect --pallet-id py/trsry --prefix 0
+  $ dot account inspect --parachain 1004 --parachain-type child
   $ dot account list
   $ dot account remove my-validator stale-key
 
@@ -2744,7 +3641,7 @@ ${YELLOW}Note: Secrets are stored unencrypted in ~/.polkadot/accounts.json.
       Hex seed import (0x...) is not supported via CLI.${RESET}
 `.trimStart();
 function registerAccountCommands(cli) {
-  cli.command("account [action] [...names]", "Manage local accounts (create, import, list, remove, export)").alias("accounts").option("--secret <value>", "Secret key (mnemonic or hex seed) for import").option("--env <varName>", "Environment variable name holding the secret").option("--path <derivation>", "Derivation path (e.g. //staking, //polkadot//0/wallet)").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").option("--file <path>", "Input/output file for batch import/export").option("--overwrite", "Overwrite existing accounts on batch import").option("--dry-run", "Preview batch import without applying changes").option("--include-secrets", "Include secrets in export (redacted by default)").option("--watch-only", "Export only watch-only accounts").option("--show-secret", "Reveal the 64-byte sr25519 expanded private key (inspect only)").action(async (action, names, opts) => {
+  cli.command("account [action] [...names]", "Manage local accounts (create, import, list, remove, export)").alias("accounts").option("--secret <value>", "Secret key (mnemonic or hex seed) for import").option("--env <varName>", "Environment variable name holding the secret").option("--path <derivation>", "Derivation path (e.g. //staking, //polkadot//0/wallet)").option("--parachain <id>", "Derive a parachain sovereign account (requires --parachain-type)").option("--parachain-type <type>", "Parachain sovereign type: child or sibling").option("--pallet-id <id>", "Derive a pallet sovereign account from an 8-byte PalletId").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").option("--file <path>", "Input/output file for batch import/export").option("--overwrite", "Overwrite existing accounts on batch import").option("--dry-run", "Preview batch import without applying changes").option("--include-secrets", "Include secrets in export (redacted by default)").option("--watch-only", "Export only watch-only accounts").option("--show-secret", "Reveal the 64-byte sr25519 expanded private key (inspect only)").action(async (action, names, opts) => {
     if (!action) {
       if (process.argv[2] === "accounts")
         return accountList(opts);
@@ -2756,8 +3653,13 @@ function registerAccountCommands(cli) {
       case "create":
         return accountCreate(names[0], opts);
       case "add":
-        if (opts.secret || opts.env)
+        if (opts.secret || opts.env) {
+          const hasDerivation = opts.parachain != null || opts.palletId != null || process.argv.includes("--parachain") || process.argv.includes("--pallet-id") || process.argv.some((a) => a.startsWith("--parachain=") || a.startsWith("--pallet-id="));
+          if (hasDerivation) {
+            throw new Error("Derivation flags (--parachain, --pallet-id) cannot be combined with --secret or --env. A derived sovereign account has no secret.");
+          }
           return accountImport(names[0], opts);
+        }
         return accountAddWatchOnly(names[0], names[1], opts);
       case "import":
         return accountBatchImport(names[0], opts);
@@ -2913,10 +3815,16 @@ async function accountAddWatchOnly(name, address, opts = {}) {
     console.error("Usage: dot account add <name> <ss58-address|0x-public-key>");
     process.exit(1);
   }
-  if (!address) {
+  const sovereignSource = resolveSovereignSource(opts);
+  if (sovereignSource && address) {
+    throw new Error("Cannot combine a positional address with --parachain or --pallet-id. Pass either an address OR a derivation flag, not both.");
+  }
+  if (!sovereignSource && !address) {
     console.error(`Address is required.
 `);
     console.error("Usage: dot account add <name> <ss58-address|0x-public-key>");
+    console.error("       dot account add <name> --parachain <id> --parachain-type <child|sibling>");
+    console.error("       dot account add <name> --pallet-id <8 chars or 0x hex>");
     process.exit(1);
   }
   if (isDevAccount(name)) {
@@ -2927,7 +3835,10 @@ async function accountAddWatchOnly(name, address, opts = {}) {
     throw new Error(`Account "${name}" already exists.`);
   }
   let hexPub;
-  if (isHexPublicKey(address)) {
+  if (sovereignSource) {
+    const accountId = sovereignSource.kind === "parachain" ? deriveSovereignAccount(sovereignSource.paraId, sovereignSource.type) : derivePalletAccount(sovereignSource.palletId);
+    hexPub = publicKeyToHex(accountId);
+  } else if (isHexPublicKey(address)) {
     hexPub = address;
   } else {
     try {
@@ -2937,21 +3848,99 @@ async function accountAddWatchOnly(name, address, opts = {}) {
       throw new Error(`Invalid address "${address}". Expected an SS58 address or 0x-prefixed 32-byte hex public key.`);
     }
   }
+  let persistedSource;
+  if (sovereignSource?.kind === "pallet") {
+    persistedSource = {
+      kind: "pallet",
+      palletId: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+    };
+  } else if (sovereignSource?.kind === "parachain") {
+    persistedSource = {
+      kind: "parachain",
+      paraId: sovereignSource.paraId,
+      type: sovereignSource.type
+    };
+  }
   accountsFile.accounts.push({
     name,
     publicKey: hexPub,
-    derivationPath: ""
+    derivationPath: "",
+    ...persistedSource ? { source: persistedSource } : {}
   });
   await saveAccounts(accountsFile);
   if (isJsonOutput(opts)) {
-    console.log(formatJson({ name, address: toSs58(hexPub), watchOnly: true }));
+    const payload = {
+      name,
+      address: toSs58(hexPub),
+      watchOnly: true
+    };
+    if (sovereignSource?.kind === "parachain") {
+      payload.derivation = {
+        kind: "parachain",
+        paraId: sovereignSource.paraId,
+        type: sovereignSource.type
+      };
+    } else if (sovereignSource?.kind === "pallet") {
+      payload.derivation = {
+        kind: "pallet",
+        palletId: formatPalletId(sovereignSource.palletId),
+        palletIdHex: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+      };
+    }
+    console.log(formatJson(payload));
     return;
   }
   printHeading("Account Added (watch-only)");
   console.log(`  ${BOLD}Name:${RESET}    ${name}`);
   console.log(`  ${BOLD}Address:${RESET} ${toSs58(hexPub)}`);
+  if (sovereignSource?.kind === "parachain") {
+    console.log(`  ${BOLD}Source:${RESET}  parachain ${sovereignSource.paraId} (${sovereignSource.type} sovereign)`);
+  } else if (sovereignSource?.kind === "pallet") {
+    const display = formatPalletId(sovereignSource.palletId);
+    const hex = `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+    console.log(`  ${BOLD}Source:${RESET}  pallet ${display} (${hex})`);
+  }
   console.log();
 }
+function rawArgValue(flag) {
+  const argv = process.argv;
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === flag && i + 1 < argv.length)
+      return argv[i + 1];
+    const prefix = `${flag}=`;
+    if (argv[i]?.startsWith(prefix))
+      return argv[i].slice(prefix.length);
+  }
+  return;
+}
+function resolveSovereignSource(opts) {
+  const rawPalletId = rawArgValue("--pallet-id") ?? opts.palletId;
+  const rawParachain = rawArgValue("--parachain") ?? opts.parachain;
+  if (rawParachain != null && rawPalletId != null) {
+    throw new Error("--parachain and --pallet-id are mutually exclusive. Pass only one derivation flag.");
+  }
+  if (rawParachain != null) {
+    const paraId = Number(rawParachain);
+    if (!isValidParaId(paraId)) {
+      throw new Error(`Invalid parachain ID "${rawParachain}". Must be a non-negative integer (0 to 4294967295).`);
+    }
+    if (!opts.parachainType) {
+      throw new Error("--parachain-type is required when --parachain is given. Use --parachain-type child or --parachain-type sibling.");
+    }
+    const type = opts.parachainType.toLowerCase();
+    if (type !== "child" && type !== "sibling") {
+      throw new Error(`Unknown parachain account type "${opts.parachainType}". Valid types: child, sibling.`);
+    }
+    return { kind: "parachain", paraId, type };
+  }
+  if (rawPalletId != null) {
+    return { kind: "pallet", palletId: parsePalletId(String(rawPalletId)) };
+  }
+  if (opts.parachainType != null) {
+    throw new Error("--parachain-type requires --parachain.");
+  }
+  return;
+}
 async function accountDerive(sourceName, newName, opts) {
   if (!sourceName) {
     console.error(`Source account name is required.
@@ -3035,69 +4024,134 @@ async function accountDerive(sourceName, newName, opts) {
     console.log();
   }
 }
+function resolveAddress(account) {
+  if (isWatchOnly(account)) {
+    return account.publicKey ? toSs58(account.publicKey) : "n/a";
+  }
+  if (account.secret !== undefined && isEnvSecret(account.secret)) {
+    const pubKey = account.publicKey || tryDerivePublicKey(account.secret.env, account.derivationPath) || "";
+    return pubKey ? toSs58(pubKey) : "n/a";
+  }
+  return toSs58(account.publicKey);
+}
+function buildAttributes(account) {
+  const attrs = [];
+  if (account.derivationPath)
+    attrs.push({ label: "path", value: account.derivationPath });
+  if (account.secret !== undefined && isEnvSecret(account.secret)) {
+    attrs.push({ label: "env", value: `$${account.secret.env}` });
+  }
+  if (account.source) {
+    if (account.source.kind === "pallet") {
+      const bytes = parsePalletId(account.source.palletId);
+      attrs.push({
+        label: "pallet-id",
+        value: `${formatPalletId(bytes)} (${account.source.palletId})`
+      });
+    } else {
+      attrs.push({ label: "parachain", value: String(account.source.paraId) });
+      attrs.push({ label: "parachain-type", value: account.source.type });
+    }
+  }
+  return attrs;
+}
+function buildRow(account) {
+  return {
+    account,
+    kind: classifyAccount(account),
+    address: resolveAddress(account),
+    attributes: buildAttributes(account)
+  };
+}
+var SECTION_ORDER = [
+  { kind: "signer", title: "Signers" },
+  { kind: "watch-only", title: "Watch-only" },
+  { kind: "pallet", title: "Pallet Sovereigns" },
+  { kind: "parachain", title: "Parachain Sovereigns" }
+];
+function printAccountSection(title, rows) {
+  if (rows.length === 0)
+    return;
+  const nameWidth = Math.max(...rows.map((r) => r.name.length));
+  printHeading(title);
+  for (const row of rows) {
+    const namePad = row.name.padEnd(nameWidth);
+    console.log(`  ${CYAN}${namePad}${RESET}  ${row.address}`);
+    if (row.attributes.length === 0)
+      continue;
+    const labelWidth = Math.max(...row.attributes.map((a) => a.label.length)) + 1;
+    for (let i = 0;i < row.attributes.length; i++) {
+      const isLast = i === row.attributes.length - 1;
+      const connector = isLast ? "└─" : "├─";
+      const labelText = `${row.attributes[i].label}:`.padEnd(labelWidth + 1);
+      console.log(`     ${DIM}${connector}${RESET} ${DIM}${labelText}${RESET}${row.attributes[i].value}`);
+    }
+  }
+}
 async function accountList(opts = {}) {
   const accountsFile = await loadAccounts();
   if (isJsonOutput(opts)) {
     const dev = DEV_NAMES.map((name) => ({
       name: name.charAt(0).toUpperCase() + name.slice(1),
-      address: getDevAddress(name)
+      address: getDevAddress(name),
+      kind: "dev"
     }));
     const stored = accountsFile.accounts.map((account) => {
-      let address;
-      if (isWatchOnly(account)) {
-        address = account.publicKey ? toSs58(account.publicKey) : undefined;
-      } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
-        let pubKey = account.publicKey;
-        if (!pubKey) {
-          pubKey = tryDerivePublicKey(account.secret.env, account.derivationPath) ?? "";
-        }
-        address = pubKey ? toSs58(pubKey) : undefined;
-      } else {
-        address = toSs58(account.publicKey);
-      }
-      return {
+      const kind = classifyAccount(account);
+      const entry = {
         name: account.name,
-        address,
-        derivationPath: account.derivationPath || undefined,
-        watchOnly: isWatchOnly(account),
-        env: account.secret !== undefined && isEnvSecret(account.secret) ? account.secret.env : undefined
+        address: resolveAddress(account),
+        kind,
+        watchOnly: isWatchOnly(account)
       };
+      if (account.derivationPath)
+        entry.derivationPath = account.derivationPath;
+      if (account.secret !== undefined && isEnvSecret(account.secret)) {
+        entry.env = account.secret.env;
+      }
+      if (account.source) {
+        if (account.source.kind === "pallet") {
+          const bytes = parsePalletId(account.source.palletId);
+          entry.source = {
+            kind: "pallet",
+            palletId: formatPalletId(bytes),
+            palletIdHex: account.source.palletId
+          };
+        } else {
+          entry.source = account.source;
+        }
+      }
+      return entry;
     });
     console.log(formatJson({ dev, stored }));
     return;
   }
-  printHeading("Dev Accounts");
-  for (const name of DEV_NAMES) {
-    const display = name.charAt(0).toUpperCase() + name.slice(1);
-    const address = getDevAddress(name);
-    printItem(display, address);
+  const devRows = DEV_NAMES.map((name) => ({
+    name: name.charAt(0).toUpperCase() + name.slice(1),
+    address: getDevAddress(name),
+    attributes: []
+  }));
+  printAccountSection("Dev Accounts", devRows);
+  const buckets = new Map;
+  for (const account of accountsFile.accounts) {
+    const row = buildRow(account);
+    const arr = buckets.get(row.kind) ?? [];
+    arr.push(row);
+    buckets.set(row.kind, arr);
+  }
+  for (const { kind, title } of SECTION_ORDER) {
+    const rows = buckets.get(kind);
+    if (!rows || rows.length === 0)
+      continue;
+    printAccountSection(title, rows.map((r) => ({
+      name: r.account.name,
+      address: r.address,
+      attributes: r.attributes
+    })));
   }
-  if (accountsFile.accounts.length > 0) {
-    printHeading("Stored Accounts");
-    for (const account of accountsFile.accounts) {
-      let displayName = account.name;
-      if (account.derivationPath) {
-        displayName += ` (${account.derivationPath})`;
-      }
-      let address;
-      if (isWatchOnly(account)) {
-        displayName += " (watch-only)";
-        address = account.publicKey ? toSs58(account.publicKey) : "n/a";
-      } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
-        displayName += ` (env: ${account.secret.env})`;
-        let pubKey = account.publicKey;
-        if (!pubKey) {
-          pubKey = tryDerivePublicKey(account.secret.env, account.derivationPath) ?? "";
-        }
-        address = pubKey ? toSs58(pubKey) : "n/a";
-      } else {
-        address = toSs58(account.publicKey);
-      }
-      printItem(displayName, address);
-    }
-  } else {
+  if (accountsFile.accounts.length === 0) {
     printHeading("Stored Accounts");
-    console.log("  (none)");
+    console.log(`  ${DIM}(none)${RESET}`);
   }
   console.log();
 }
@@ -3145,10 +4199,20 @@ async function accountRemove(names, opts = {}) {
   }
 }
 async function accountInspect(input, opts) {
-  if (!input) {
+  const sovereignSource = resolveSovereignSource({
+    parachain: opts.parachain,
+    parachainType: opts.parachainType,
+    palletId: opts.palletId
+  });
+  if (sovereignSource && input) {
+    throw new Error("Cannot combine a positional input with --parachain or --pallet-id. Pass either an existing-account input OR a derivation flag, not both.");
+  }
+  if (!sovereignSource && !input) {
     console.error(`Input is required.
 `);
     console.error("Usage: dot account inspect <name|ss58-address|0x-public-key> [--prefix <N>]");
+    console.error("       dot account inspect --pallet-id <id> [--prefix <N>]");
+    console.error("       dot account inspect --parachain <id> --parachain-type <child|sibling> [--prefix <N>]");
     process.exit(1);
   }
   const prefix = opts.prefix != null ? Number(opts.prefix) : 42;
@@ -3160,11 +4224,32 @@ async function accountInspect(input, opts) {
   let publicKeyHex;
   let bandersnatch;
   let hasSecret = false;
-  if (isDevAccount(input)) {
+  let storedAccount;
+  let isDev = false;
+  let virtualSource;
+  if (sovereignSource) {
+    if (sovereignSource.kind === "pallet") {
+      const accountId = derivePalletAccount(sovereignSource.palletId);
+      publicKeyHex = publicKeyToHex(accountId);
+      virtualSource = {
+        kind: "pallet",
+        palletIdHex: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+      };
+    } else {
+      const accountId = deriveSovereignAccount(sovereignSource.paraId, sovereignSource.type);
+      publicKeyHex = publicKeyToHex(accountId);
+      virtualSource = {
+        kind: "parachain",
+        paraId: sovereignSource.paraId,
+        type: sovereignSource.type
+      };
+    }
+  } else if (isDevAccount(input)) {
     name = input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
     const devAddr = getDevAddress(input);
     publicKeyHex = publicKeyToHex(fromSs58(devAddr));
     hasSecret = true;
+    isDev = true;
   } else {
     const accountsFile = await loadAccounts();
     const account = findAccount(accountsFile, input);
@@ -3172,6 +4257,7 @@ async function accountInspect(input, opts) {
       name = account.name;
       bandersnatch = account.bandersnatch;
       hasSecret = account.secret !== undefined;
+      storedAccount = account;
       if (account.publicKey) {
         publicKeyHex = account.publicKey;
       } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
@@ -3215,10 +4301,74 @@ async function accountInspect(input, opts) {
       process.exit(1);
     }
   }
+  let kindLabel;
+  let sourceLine;
+  let derivationLine;
+  let envLine;
+  if (virtualSource?.kind === "pallet") {
+    kindLabel = "pallet sovereign";
+    const bytes = parsePalletId(virtualSource.palletIdHex);
+    sourceLine = `PalletId ${formatPalletId(bytes)} (${virtualSource.palletIdHex})`;
+  } else if (virtualSource?.kind === "parachain") {
+    kindLabel = `parachain sovereign (${virtualSource.type})`;
+    sourceLine = `parachain ${virtualSource.paraId}`;
+  } else if (isDev) {
+    kindLabel = "dev";
+  } else if (storedAccount) {
+    const k = classifyAccount(storedAccount);
+    if (k === "pallet" && storedAccount.source?.kind === "pallet") {
+      kindLabel = "pallet sovereign";
+      const bytes = parsePalletId(storedAccount.source.palletId);
+      sourceLine = `PalletId ${formatPalletId(bytes)} (${storedAccount.source.palletId})`;
+    } else if (k === "parachain" && storedAccount.source?.kind === "parachain") {
+      kindLabel = `parachain sovereign (${storedAccount.source.type})`;
+      sourceLine = `parachain ${storedAccount.source.paraId}`;
+    } else if (k === "signer") {
+      kindLabel = "signer";
+    } else {
+      kindLabel = "watch-only";
+    }
+    if (storedAccount.derivationPath)
+      derivationLine = storedAccount.derivationPath;
+    if (storedAccount.secret !== undefined && isEnvSecret(storedAccount.secret)) {
+      envLine = `$${storedAccount.secret.env}`;
+    }
+  }
   if (isJsonOutput(opts)) {
     const result = { publicKey: publicKeyHex, ss58, prefix };
     if (name)
       result.name = name;
+    if (kindLabel)
+      result.kind = kindLabel;
+    if (virtualSource?.kind === "pallet") {
+      const bytes = parsePalletId(virtualSource.palletIdHex);
+      result.source = {
+        kind: "pallet",
+        palletId: formatPalletId(bytes),
+        palletIdHex: virtualSource.palletIdHex
+      };
+    } else if (virtualSource?.kind === "parachain") {
+      result.source = {
+        kind: "parachain",
+        paraId: virtualSource.paraId,
+        type: virtualSource.type
+      };
+    } else if (storedAccount?.source) {
+      if (storedAccount.source.kind === "pallet") {
+        const bytes = parsePalletId(storedAccount.source.palletId);
+        result.source = {
+          kind: "pallet",
+          palletId: formatPalletId(bytes),
+          palletIdHex: storedAccount.source.palletId
+        };
+      } else {
+        result.source = storedAccount.source;
+      }
+    }
+    if (derivationLine)
+      result.derivationPath = derivationLine;
+    if (envLine)
+      result.env = envLine.replace(/^\$/, "");
     if (bandersnatch && Object.keys(bandersnatch).length > 0)
       result.bandersnatch = bandersnatch;
     if (privateKeyHex)
@@ -3228,8 +4378,16 @@ async function accountInspect(input, opts) {
     printHeading("Account Info");
     if (name)
       console.log(`  ${BOLD}Name:${RESET}        ${name}`);
+    if (kindLabel)
+      console.log(`  ${BOLD}Kind:${RESET}        ${kindLabel}`);
     console.log(`  ${BOLD}Public Key:${RESET}  ${publicKeyHex}`);
     console.log(`  ${BOLD}SS58:${RESET}        ${ss58}`);
+    if (sourceLine)
+      console.log(`  ${BOLD}Source:${RESET}      ${sourceLine}`);
+    if (derivationLine)
+      console.log(`  ${BOLD}Derivation:${RESET}  ${derivationLine}`);
+    if (envLine)
+      console.log(`  ${BOLD}Env:${RESET}         ${envLine}`);
     if (bandersnatch && Object.keys(bandersnatch).length > 0) {
       const entries = Object.entries(bandersnatch);
       for (let i = 0;i < entries.length; i++) {
@@ -3533,6 +4691,53 @@ init_client();
 init_metadata();
 init_output();
 import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+
+// src/core/rpc.ts
+init_errors();
+import { createClient as createSubstrateClient } from "@polkadot-api/substrate-client";
+import { getWsProvider as getWsProvider2 } from "polkadot-api/ws";
+function suppressProviderNoise2() {
+  const origError = console.error;
+  console.error = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("Unable to connect"))
+      return;
+    origError(...args);
+  };
+  return () => {
+    console.error = origError;
+  };
+}
+async function rpcRequest(rpcUrl, method, params, timeoutMs = 30000) {
+  const restoreConsole = suppressProviderNoise2();
+  const provider = getWsProvider2(rpcUrl, { timeout: 1e4 });
+  const client = createSubstrateClient(provider);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await client.request(method, params, controller.signal);
+  } catch (err) {
+    if (err instanceof Error && /Unable to connect/i.test(err.message)) {
+      throw new ConnectionError(`Could not reach RPC ${Array.isArray(rpcUrl) ? rpcUrl.join(", ") : rpcUrl}: ${err.message}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+    try {
+      client.destroy();
+    } catch {}
+    setTimeout(restoreConsole, 100);
+  }
+}
+async function fetchRpcMethods(rpcUrl) {
+  const result = await rpcRequest(rpcUrl, "rpc_methods", []);
+  if (!result || !Array.isArray(result.methods)) {
+    throw new ConnectionError("Node returned an unexpected response for rpc_methods (no methods array).");
+  }
+  return { methods: result.methods, version: result.version ?? 1 };
+}
+
+// src/commands/chain.ts
+init_rpc_registry();
 var CHAIN_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot chain add <name> --rpc <url>    Add a chain via WebSocket RPC
@@ -3540,6 +4745,8 @@ ${BOLD}Usage:${RESET}
   $ dot chain update <name>             Re-fetch metadata for a chain
   $ dot chain update --all              Re-fetch metadata for all configured chains
   $ dot chain list                      List configured chains
+  $ dot chain info <name>               Show details for a single chain
+  $ dot chain <name>                    Shortcut for \`chain info <name>\`
   $ dot chain export [names...]         Export chain configuration to stdout
   $ dot chain import <file>             Import chain configuration from a file
 
@@ -3549,6 +4756,9 @@ ${BOLD}Examples:${RESET}
   $ dot chain add my-para --rpc wss://rpc.example.com --relay polkadot
   $ dot chain add my-para --rpc wss://rpc.example.com --relay polkadot --parachain-id 2000
   $ dot chain list
+  $ dot chains -v
+  $ dot chain info polkadot
+  $ dot chain polkadot
   $ dot chain update kusama
   $ dot chain update --all
   $ dot chain remove kusama
@@ -3561,7 +4771,7 @@ ${BOLD}Examples:${RESET}
   $ dot chain import my-chains.json --no-metadata
 `.trimStart();
 function registerChainCommands(cli) {
-  cli.command("chain [action] [...names]", "Manage chains (add, remove, update, list, export, import)").alias("chains").option("--all", "Update/export all configured chains").option("--relay <name>", "Parent relay chain for this parachain").option("--parachain-id <id>", "Parachain ID (auto-detected if omitted with --relay)").option("--file <path>", "Output/input file for export/import").option("--overwrite", "Overwrite existing chains on import").option("--dry-run", "Preview import without applying changes").option("--no-metadata", "Skip automatic metadata fetch after import").action(async (action, names, opts) => {
+  cli.command("chain [action] [...names]", "Manage chains (add, remove, update, list, export, import)").alias("chains").option("--all", "Update/export all configured chains").option("--relay <name>", "Parent relay chain for this parachain").option("--parachain-id <id>", "Parachain ID (auto-detected if omitted with --relay)").option("--file <path>", "Output/input file for export/import").option("--overwrite", "Overwrite existing chains on import").option("--dry-run", "Preview import without applying changes").option("--no-metadata", "Skip automatic metadata fetch after import").option("-v, --verbose", "Show RPC endpoints in `chains` list output").action(async (action, names, opts) => {
     if (!action) {
       if (process.argv[2] === "chains")
         return chainList(opts);
@@ -3575,20 +4785,39 @@ function registerChainCommands(cli) {
         return chainRemove(names[0], opts);
       case "list":
         return chainList(opts);
+      case "info":
+        return chainInfo(names[0], opts);
       case "update":
         return chainUpdate(names[0], opts);
       case "export":
         return chainExport(names, opts);
       case "import":
         return chainImport(names[0], opts);
-      default:
+      default: {
+        const config = await loadConfig();
+        if (findChainName(config, action)) {
+          return chainInfo(action, opts);
+        }
         console.error(`Unknown action "${action}".
 `);
         console.log(CHAIN_HELP);
         process.exit(1);
+      }
     }
   });
 }
+async function refreshRpcMethods(chainName, rpcUrl, silent = false) {
+  try {
+    const { methods, version: version2 } = await fetchRpcMethods(rpcUrl);
+    await saveRpcMethods(chainName, methods, version2);
+  } catch (err) {
+    if (!silent) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`${YELLOW}Warning:${RESET} could not fetch rpc_methods — ${msg}
+`);
+    }
+  }
+}
 async function chainAdd(name, opts) {
   if (!name) {
     console.error(`Chain name is required.
@@ -3617,6 +4846,7 @@ async function chainAdd(name, opts) {
     process.stderr.write(`Fetching metadata...
 `);
     await fetchMetadataFromChain(clientHandle, name);
+    await refreshRpcMethods(name, opts.rpc);
     if (opts.relay) {
       const config2 = await loadConfig();
       const relayResolved = findChainName(config2, opts.relay);
@@ -3695,6 +4925,7 @@ async function chainList(opts = {}) {
     console.log(formatJson({ chains }));
     return;
   }
+  const verbose = opts.verbose === true;
   printHeading("Configured Chains");
   const parachainsByRelay = new Map;
   const standalone = [];
@@ -3716,7 +4947,7 @@ async function chainList(opts = {}) {
   for (const relayName of relayNames) {
     const relayConfig = config.chains[relayName];
     if (relayConfig) {
-      printChainLine("  ", relayName, relayConfig);
+      printChainLine("  ", relayName, relayConfig, "", verbose);
     }
     const paras = parachainsByRelay.get(relayName) ?? [];
     for (let i = 0;i < paras.length; i++) {
@@ -3724,17 +4955,21 @@ async function chainList(opts = {}) {
       const isLast = i === paras.length - 1;
       const prefix = isLast ? "  └─ " : "  ├─ ";
       const idSuffix = chainConfig.parachainId != null ? ` ${DIM}[${chainConfig.parachainId}]${RESET}` : "";
-      printChainLine(prefix, name, chainConfig, idSuffix);
+      printChainLine(prefix, name, chainConfig, idSuffix, verbose);
     }
     console.log();
   }
   for (const [name, chainConfig] of standalone) {
-    printChainLine("  ", name, chainConfig);
+    printChainLine("  ", name, chainConfig, "", verbose);
   }
   if (standalone.length > 0)
     console.log();
 }
-function printChainLine(prefix, name, chainConfig, suffix = "") {
+function printChainLine(prefix, name, chainConfig, suffix = "", verbose = false) {
+  if (!verbose) {
+    console.log(`${prefix}${CYAN}${name}${RESET}${suffix}`);
+    return;
+  }
   const rpcs = Array.isArray(chainConfig.rpc) ? chainConfig.rpc : [chainConfig.rpc];
   console.log(`${prefix}${CYAN}${name}${RESET}${suffix}  ${DIM}${rpcs[0]}${RESET}`);
   const indent = prefix.replace(/[^\s]/g, " ");
@@ -3742,6 +4977,79 @@ function printChainLine(prefix, name, chainConfig, suffix = "") {
     console.log(`${indent}  ${DIM}${rpcs[i]}${RESET}`);
   }
 }
+async function chainInfo(name, opts = {}) {
+  if (!name) {
+    console.error("Usage: dot chain info <name>");
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const { name: resolved, chain } = resolveChain(config, name);
+  const rpcs = Array.isArray(chain.rpc) ? chain.rpc : [chain.rpc];
+  const parachains = Object.entries(config.chains).filter(([, c]) => c.relay === resolved).map(([n, c]) => ({ name: n, parachainId: c.parachainId }));
+  const fingerprint = await loadMetadataFingerprint(resolved);
+  const rpcCache = await loadRpcMethods(resolved);
+  const rpcSummary = rpcCache ? {
+    count: rpcCache.methods.length,
+    fetchedAt: rpcCache.fetchedAt,
+    byFamily: countByFamily(rpcCache.methods)
+  } : null;
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      name: resolved,
+      rpc: rpcs,
+      ...chain.relay && { relay: chain.relay },
+      ...chain.parachainId != null && { parachainId: chain.parachainId },
+      ...parachains.length > 0 && { parachains },
+      metadata: fingerprint ? {
+        specName: fingerprint.specName,
+        specVersion: fingerprint.specVersion,
+        fetchedAt: fingerprint.fetchedAt
+      } : null,
+      rpcMethods: rpcSummary
+    }));
+    return;
+  }
+  printHeading(resolved);
+  console.log(`  ${CYAN}rpc:${RESET}`);
+  for (const rpc of rpcs) {
+    console.log(`    ${DIM}${rpc}${RESET}`);
+  }
+  if (chain.relay) {
+    console.log(`  ${CYAN}relay:${RESET}        ${chain.relay}`);
+  }
+  if (chain.parachainId != null) {
+    console.log(`  ${CYAN}parachain id:${RESET} ${chain.parachainId}`);
+  }
+  if (parachains.length > 0) {
+    console.log(`  ${CYAN}parachains:${RESET}`);
+    for (const p of parachains) {
+      const idSuffix = p.parachainId != null ? ` ${DIM}[${p.parachainId}]${RESET}` : "";
+      console.log(`    ${p.name}${idSuffix}`);
+    }
+  }
+  console.log(`  ${CYAN}metadata:${RESET}`);
+  if (fingerprint) {
+    console.log(`    ${fingerprint.specName} v${fingerprint.specVersion} ${DIM}(cached ${fingerprint.fetchedAt})${RESET}`);
+  } else {
+    console.log(`    ${DIM}not cached — run \`dot chain update ${resolved}\`${RESET}`);
+  }
+  console.log(`  ${CYAN}rpc methods:${RESET}`);
+  if (rpcSummary) {
+    const families = Object.entries(rpcSummary.byFamily).map(([f, n]) => `${f}: ${n}`).join(", ");
+    console.log(`    ${rpcSummary.count} ${DIM}(${families})${RESET}`);
+    console.log(`    ${DIM}cached ${rpcSummary.fetchedAt}${RESET}`);
+  } else {
+    console.log(`    ${DIM}not cached — run \`dot chain update ${resolved}\`${RESET}`);
+  }
+}
+function countByFamily(methods) {
+  const counts = {};
+  for (const m of methods) {
+    const family = RPC_REGISTRY[m]?.family ?? inferFamily(m);
+    counts[family] = (counts[family] ?? 0) + 1;
+  }
+  return counts;
+}
 async function chainUpdate(name, opts) {
   const config = await loadConfig();
   if (opts.all) {
@@ -3760,6 +5068,7 @@ async function chainUpdate(name, opts) {
     process.stderr.write(`Fetching metadata...
 `);
     await fetchMetadataFromChain(clientHandle, chainName);
+    await refreshRpcMethods(chainName, opts.rpc ?? chainConfig.rpc);
     if (isJsonOutput(opts)) {
       console.log(formatJson({ action: "updated", chain: chainName }));
     } else {
@@ -3789,6 +5098,7 @@ async function updateChainsMetadata(config, chainNames) {
     const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       await fetchMetadataFromChain(clientHandle, chainName);
+      await refreshRpcMethods(chainName, chainConfig.rpc, true);
     } finally {
       clientHandle.destroy();
     }
@@ -4118,6 +5428,7 @@ init_store();
 init_client();
 init_metadata();
 init_output();
+init_pretty_type();
 async function loadMeta2(chainName, chainConfig, rpcOverride) {
   if (rpcOverride) {
     process.stderr.write(`Fetching metadata from ${chainName}...
@@ -4202,8 +5513,11 @@ async function handleCalls2(target, opts) {
     }
     printHeading(`${pallet.name} Calls`);
     for (const c of pallet.calls) {
-      const args2 = describeCallArgs(meta, pallet.name, c.name);
-      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${args2}${RESET}`);
+      const args2 = prettyCallArgs(meta, pallet.name, c.name, {
+        indent: 2,
+        prefix: c.name.length
+      });
+      console.log(`  ${CYAN}${c.name}${RESET}${args2}`);
       const summary = firstSentence(c.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -4229,7 +5543,10 @@ async function handleCalls2(target, opts) {
     return;
   }
   printHeading(`${pallet.name}.${callItem.name} (Call)`);
-  const args = describeCallArgs(meta, pallet.name, callItem.name);
+  const args = prettyCallArgs(meta, pallet.name, callItem.name, {
+    indent: 2,
+    prefix: 6
+  });
   console.log(`  ${BOLD}Args:${RESET} ${args}`);
   if (callItem.docs.length) {
     console.log();
@@ -4288,8 +5605,11 @@ async function handleEvents2(target, opts) {
     }
     printHeading(`${pallet.name} Events`);
     for (const e of pallet.events) {
-      const fields2 = describeEventFields(meta, pallet.name, e.name);
-      console.log(`  ${CYAN}${e.name}${RESET}${DIM}${fields2}${RESET}`);
+      const fields2 = prettyEventFields(meta, pallet.name, e.name, {
+        indent: 2,
+        prefix: e.name.length
+      });
+      console.log(`  ${CYAN}${e.name}${RESET}${fields2}`);
       const summary = firstSentence(e.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -4315,7 +5635,10 @@ async function handleEvents2(target, opts) {
     return;
   }
   printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-  const fields = describeEventFields(meta, pallet.name, eventItem.name);
+  const fields = prettyEventFields(meta, pallet.name, eventItem.name, {
+    indent: 2,
+    prefix: 8
+  });
   console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
   if (eventItem.docs.length) {
     console.log();
@@ -4442,24 +5765,30 @@ async function handleStorage2(target, opts) {
         chain: chainName,
         pallet: pallet.name,
         storage: pallet.storage.map((s) => {
-          const valueType = describeType(meta.lookup, s.valueTypeId);
+          const valueType2 = describeType(meta.lookup, s.valueTypeId);
           const keyType = s.keyTypeId != null ? describeType(meta.lookup, s.keyTypeId) : undefined;
-          return { name: s.name, type: s.type, valueType, keyType, docs: firstSentence(s.docs) };
+          return { name: s.name, type: s.type, valueType: valueType2, keyType, docs: firstSentence(s.docs) };
         })
       }));
       return;
     }
     printHeading(`${pallet.name} Storage`);
     for (const s of pallet.storage) {
-      const valueType = describeType(meta.lookup, s.valueTypeId);
-      let typeSuffix;
-      if (s.keyTypeId != null) {
-        const keyType = describeType(meta.lookup, s.keyTypeId);
-        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
-      } else {
-        typeSuffix = `: ${valueType}`;
+      const isMap = s.keyTypeId != null;
+      const tag = isMap ? `${DIM} [map]${RESET}` : "";
+      console.log(`  ${CYAN}${s.name}${RESET}${tag}`);
+      if (isMap) {
+        const keyType = prettyTypeById(meta.lookup, s.keyTypeId, {
+          indent: 4,
+          prefix: 5
+        });
+        console.log(`    ${DIM}Key:${RESET}   ${keyType}`);
       }
-      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const valueType2 = prettyTypeById(meta.lookup, s.valueTypeId, {
+        indent: 4,
+        prefix: 7
+      });
+      console.log(`    ${DIM}Value:${RESET} ${valueType2}`);
       const summary = firstSentence(s.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -4474,7 +5803,7 @@ async function handleStorage2(target, opts) {
     throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
   }
   if (isJsonOutput(opts)) {
-    const valueType = describeType(meta.lookup, storageItem.valueTypeId);
+    const valueType2 = describeType(meta.lookup, storageItem.valueTypeId);
     const keyType = storageItem.keyTypeId != null ? describeType(meta.lookup, storageItem.keyTypeId) : undefined;
     console.log(formatJson({
       chain: chainName,
@@ -4482,18 +5811,26 @@ async function handleStorage2(target, opts) {
       item: storageItem.name,
       category: "storage",
       type: storageItem.type,
-      valueType,
+      valueType: valueType2,
       keyType,
       docs: storageItem.docs
     }));
     return;
   }
   printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-  console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-  console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+  console.log(`  ${BOLD}Type:${RESET}  ${storageItem.type}`);
   if (storageItem.keyTypeId != null) {
-    console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+    const keyType = prettyTypeById(meta.lookup, storageItem.keyTypeId, {
+      indent: 2,
+      prefix: 7
+    });
+    console.log(`  ${BOLD}Key:${RESET}   ${keyType}`);
   }
+  const valueType = prettyTypeById(meta.lookup, storageItem.valueTypeId, {
+    indent: 2,
+    prefix: 7
+  });
+  console.log(`  ${BOLD}Value:${RESET} ${valueType}`);
   if (storageItem.docs.length) {
     console.log();
     printDocs(storageItem.docs);
@@ -4524,9 +5861,15 @@ async function showItemHelp2(category, target, opts) {
       throw new Error(suggestMessage(`method in ${api.name}`, methodName, names));
     }
     printHeading(`${api.name}.${method.name} (Runtime API)`);
-    const argStr = describeRuntimeApiMethodArgs(meta, method);
-    const retStr = describeType(meta.lookup, method.output);
-    console.log(`  ${BOLD}Args:${RESET} ${argStr}`);
+    const argStr = prettyRuntimeApiArgs(meta.lookup, method.inputs, {
+      indent: 2,
+      prefix: 9
+    });
+    const retStr = prettyTypeById(meta.lookup, method.output, {
+      indent: 2,
+      prefix: 9
+    });
+    console.log(`  ${BOLD}Args:${RESET}    ${argStr}`);
     console.log(`  ${BOLD}Returns:${RESET} ${retStr}`);
     if (method.docs.length) {
       console.log();
@@ -4569,7 +5912,10 @@ async function showItemHelp2(category, target, opts) {
         throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${callItem.name} (Call)`);
-      const args = describeCallArgs(meta, pallet.name, callItem.name);
+      const args = prettyCallArgs(meta, pallet.name, callItem.name, {
+        indent: 2,
+        prefix: 6
+      });
       console.log(`  ${BOLD}Args:${RESET} ${args}`);
       if (callItem.docs.length) {
         console.log();
@@ -4596,11 +5942,19 @@ async function showItemHelp2(category, target, opts) {
         throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      console.log(`  ${BOLD}Type:${RESET}  ${storageItem.type}`);
       if (storageItem.keyTypeId != null) {
-        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+        const keyType = prettyTypeById(meta.lookup, storageItem.keyTypeId, {
+          indent: 2,
+          prefix: 7
+        });
+        console.log(`  ${BOLD}Key:${RESET}   ${keyType}`);
       }
+      const valueType = prettyTypeById(meta.lookup, storageItem.valueTypeId, {
+        indent: 2,
+        prefix: 7
+      });
+      console.log(`  ${BOLD}Value:${RESET} ${valueType}`);
       if (storageItem.docs.length) {
         console.log();
         printDocs(storageItem.docs);
@@ -4627,7 +5981,11 @@ async function showItemHelp2(category, target, opts) {
         throw new Error(suggestMessage(`constant in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${constItem.name} (Constant)`);
-      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constItem.typeId)}`);
+      const constType = prettyTypeById(meta.lookup, constItem.typeId, {
+        indent: 2,
+        prefix: 6
+      });
+      console.log(`  ${BOLD}Type:${RESET} ${constType}`);
       if (constItem.docs.length) {
         console.log();
         printDocs(constItem.docs);
@@ -4645,7 +6003,10 @@ async function showItemHelp2(category, target, opts) {
         throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
       }
       printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-      const fields = describeEventFields(meta, pallet.name, eventItem.name);
+      const fields = prettyEventFields(meta, pallet.name, eventItem.name, {
+        indent: 2,
+        prefix: 8
+      });
       console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
       if (eventItem.docs.length) {
         console.log();
@@ -4720,8 +6081,16 @@ async function handleExtensions(target, opts) {
     return;
   }
   printHeading(`${described.identifier} (Transaction Extension)`);
-  console.log(`  ${BOLD}Value type:${RESET}       ${described.valueType}`);
-  console.log(`  ${BOLD}AdditionalSigned:${RESET} ${described.additionalSignedType}`);
+  const valueType = prettyTypeById(meta.lookup, described.valueTypeId, {
+    indent: 2,
+    prefix: 18
+  });
+  const addSigType = prettyTypeById(meta.lookup, described.additionalSignedTypeId, {
+    indent: 2,
+    prefix: 18
+  });
+  console.log(`  ${BOLD}Value type:${RESET}       ${valueType}`);
+  console.log(`  ${BOLD}AdditionalSigned:${RESET} ${addSigType}`);
   console.log(`  ${BOLD}Handled by:${RESET}       ${described.isBuiltin ? "polkadot-api (builtin)" : "user (custom — provide via --ext)"}`);
   if (!described.isBuiltin) {
     console.log();
@@ -4805,6 +6174,7 @@ init_store();
 init_client();
 init_metadata();
 init_output();
+init_pretty_type();
 
 // src/utils/parse-target.ts
 function parseTarget(input, options) {
@@ -4981,15 +6351,21 @@ function registerInspectCommand(cli) {
       if (pallet2.storage.length) {
         console.log(`  ${BOLD}Storage Items:${RESET}`);
         for (const s of pallet2.storage) {
-          const valueType = describeType(meta.lookup, s.valueTypeId);
-          let typeSuffix;
-          if (s.keyTypeId != null) {
-            const keyType = describeType(meta.lookup, s.keyTypeId);
-            typeSuffix = `: ${keyType} → ${valueType}    [map]`;
-          } else {
-            typeSuffix = `: ${valueType}`;
+          const isMap = s.keyTypeId != null;
+          const tag = isMap ? `${DIM} [map]${RESET}` : "";
+          console.log(`    ${CYAN}${s.name}${RESET}${tag}`);
+          if (isMap) {
+            const keyType = prettyTypeById(meta.lookup, s.keyTypeId, {
+              indent: 6,
+              prefix: 7
+            });
+            console.log(`      ${DIM}Key:${RESET}   ${keyType}`);
           }
-          console.log(`    ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+          const valueType = prettyTypeById(meta.lookup, s.valueTypeId, {
+            indent: 6,
+            prefix: 7
+          });
+          console.log(`      ${DIM}Value:${RESET} ${valueType}`);
           const summary = firstSentence(s.docs);
           if (summary) {
             console.log(`        ${DIM}${summary}${RESET}`);
@@ -5000,8 +6376,11 @@ function registerInspectCommand(cli) {
       if (pallet2.constants.length) {
         console.log(`  ${BOLD}Constants:${RESET}`);
         for (const c of pallet2.constants) {
-          const typeStr = describeType(meta.lookup, c.typeId);
-          console.log(`    ${CYAN}${c.name}${RESET}${DIM}: ${typeStr}${RESET}`);
+          const typeStr = prettyTypeById(meta.lookup, c.typeId, {
+            indent: 4,
+            prefix: c.name.length + 2
+          });
+          console.log(`    ${CYAN}${c.name}${RESET}: ${typeStr}`);
           const summary = firstSentence(c.docs);
           if (summary) {
             console.log(`        ${DIM}${summary}${RESET}`);
@@ -5012,8 +6391,11 @@ function registerInspectCommand(cli) {
       if (pallet2.calls.length) {
         console.log(`  ${BOLD}Calls:${RESET}`);
         for (const c of pallet2.calls) {
-          const args = describeCallArgs(meta, pallet2.name, c.name);
-          console.log(`    ${CYAN}${c.name}${RESET}${DIM}${args}${RESET}`);
+          const args = prettyCallArgs(meta, pallet2.name, c.name, {
+            indent: 4,
+            prefix: c.name.length
+          });
+          console.log(`    ${CYAN}${c.name}${RESET}${args}`);
           const summary = firstSentence(c.docs);
           if (summary) {
             console.log(`        ${DIM}${summary}${RESET}`);
@@ -5024,8 +6406,11 @@ function registerInspectCommand(cli) {
       if (pallet2.events.length) {
         console.log(`  ${BOLD}Events:${RESET}`);
         for (const e of pallet2.events) {
-          const fields = describeEventFields(meta, pallet2.name, e.name);
-          console.log(`    ${CYAN}${e.name}${RESET}${DIM}${fields}${RESET}`);
+          const fields = prettyEventFields(meta, pallet2.name, e.name, {
+            indent: 4,
+            prefix: e.name.length
+          });
+          console.log(`    ${CYAN}${e.name}${RESET}${fields}`);
           const summary = firstSentence(e.docs);
           if (summary) {
             console.log(`        ${DIM}${summary}${RESET}`);
@@ -5127,11 +6512,19 @@ function registerInspectCommand(cli) {
     const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
     if (storageItem) {
       printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      console.log(`  ${BOLD}Type:${RESET}  ${storageItem.type}`);
       if (storageItem.keyTypeId != null) {
-        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+        const keyType = prettyTypeById(meta.lookup, storageItem.keyTypeId, {
+          indent: 2,
+          prefix: 7
+        });
+        console.log(`  ${BOLD}Key:${RESET}   ${keyType}`);
       }
+      const valueType = prettyTypeById(meta.lookup, storageItem.valueTypeId, {
+        indent: 2,
+        prefix: 7
+      });
+      console.log(`  ${BOLD}Value:${RESET} ${valueType}`);
       if (storageItem.docs.length) {
         console.log();
         printDocs(storageItem.docs);
@@ -5142,7 +6535,11 @@ function registerInspectCommand(cli) {
     const constantItem = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
     if (constantItem) {
       printHeading(`${pallet.name}.${constantItem.name} (Constant)`);
-      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constantItem.typeId)}`);
+      const typeStr = prettyTypeById(meta.lookup, constantItem.typeId, {
+        indent: 2,
+        prefix: 6
+      });
+      console.log(`  ${BOLD}Type:${RESET} ${typeStr}`);
       if (constantItem.docs.length) {
         console.log();
         printDocs(constantItem.docs);
@@ -5153,7 +6550,10 @@ function registerInspectCommand(cli) {
     const callItem = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
     if (callItem) {
       printHeading(`${pallet.name}.${callItem.name} (Call)`);
-      const args = describeCallArgs(meta, pallet.name, callItem.name);
+      const args = prettyCallArgs(meta, pallet.name, callItem.name, {
+        indent: 2,
+        prefix: 6
+      });
       console.log(`  ${BOLD}Args:${RESET} ${args}`);
       if (callItem.docs.length) {
         console.log();
@@ -5165,7 +6565,10 @@ function registerInspectCommand(cli) {
     const eventItem = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
     if (eventItem) {
       printHeading(`${pallet.name}.${eventItem.name} (Event)`);
-      const fields = describeEventFields(meta, pallet.name, eventItem.name);
+      const fields = prettyEventFields(meta, pallet.name, eventItem.name, {
+        indent: 2,
+        prefix: 8
+      });
       console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
       if (eventItem.docs.length) {
         console.log();
@@ -5240,11 +6643,6 @@ async function handleMetadata(chain, opts) {
   await writeStdout(`${formatJson(buildMetadataPayload(chainName, meta, fingerprint))}
 `);
 }
-function writeStdout(text) {
-  return new Promise((resolve) => {
-    process.stdout.write(text, () => resolve());
-  });
-}
 function registerMetadataCommand(cli) {
   cli.command("metadata <chain>", "Fetch chain metadata (decoded JSON; --raw for SCALE hex)").option("--raw", "Print SCALE-encoded metadata bytes as hex instead of decoded JSON").option("--cached", "Use cached metadata instead of fetching fresh from the chain").option("--rpc <url>", "Override RPC endpoint(s)").action((chain, opts) => handleMetadata(chain, opts));
 }
@@ -5252,24 +6650,6 @@ function registerMetadataCommand(cli) {
 // src/commands/parachain.ts
 init_accounts();
 init_output();
-
-// src/core/parachain.ts
-var SOVEREIGN_ACCOUNT_TYPES = ["child", "sibling"];
-var PREFIXES = {
-  child: new Uint8Array([112, 97, 114, 97]),
-  sibling: new Uint8Array([115, 105, 98, 108])
-};
-function deriveSovereignAccount(paraId, type) {
-  const result = new Uint8Array(32);
-  result.set(PREFIXES[type], 0);
-  new DataView(result.buffer).setUint32(4, paraId, true);
-  return result;
-}
-function isValidParaId(value) {
-  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
-}
-
-// src/commands/parachain.ts
 init_errors();
 function printParachainHelp() {
   console.log(`${BOLD}Usage:${RESET} dot parachain <paraId> [options]
@@ -5299,6 +6679,7 @@ function validateType(type) {
 }
 function registerParachainCommand(cli) {
   cli.command("parachain [paraId]", "Derive parachain sovereign accounts").option("--type <type>", "Account type: child, sibling (default: both)").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").action(async (paraIdStr, opts) => {
+    console.error("Warning: `dot parachain` is deprecated; use `dot account inspect --parachain <id> --parachain-type <child|sibling>` instead. Will be removed in a future release.");
     if (!paraIdStr) {
       printParachainHelp();
       return;
@@ -5344,6 +6725,7 @@ init_store();
 init_client();
 init_metadata();
 init_output();
+init_pretty_type();
 init_focused_inspect();
 init_tx();
 async function handleQuery(target, keys, opts) {
@@ -5354,10 +6736,11 @@ async function handleQuery(target, keys, opts) {
     const pallets = listPallets(meta);
     const withStorage = pallets.filter((p) => p.storage.length > 0);
     if (isJsonOutput(opts)) {
-      console.log(formatJson({
+      await writeStdout(`${formatJson({
         chain: chainName2,
         pallets: withStorage.map((p) => ({ name: p.name, storage: p.storage.length }))
-      }));
+      })}
+`);
       return;
     }
     printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
@@ -5375,14 +6758,15 @@ async function handleQuery(target, keys, opts) {
     const pallet2 = resolvePallet(meta, palletName(target));
     if (pallet2.storage.length === 0) {
       if (isJsonOutput(opts)) {
-        console.log(formatJson({ chain: chainName2, pallet: pallet2.name, storage: [] }));
+        await writeStdout(`${formatJson({ chain: chainName2, pallet: pallet2.name, storage: [] })}
+`);
       } else {
         console.log(`No storage items in ${pallet2.name}.`);
       }
       return;
     }
     if (isJsonOutput(opts)) {
-      console.log(formatJson({
+      await writeStdout(`${formatJson({
         chain: chainName2,
         pallet: pallet2.name,
         storage: pallet2.storage.map((s) => {
@@ -5390,20 +6774,27 @@ async function handleQuery(target, keys, opts) {
           const keyType = s.keyTypeId != null ? describeType(meta.lookup, s.keyTypeId) : undefined;
           return { name: s.name, type: s.type, valueType, keyType, docs: firstSentence(s.docs) };
         })
-      }));
+      })}
+`);
       return;
     }
     printHeading(`${pallet2.name} Storage`);
     for (const s of pallet2.storage) {
-      const valueType = describeType(meta.lookup, s.valueTypeId);
-      let typeSuffix;
-      if (s.keyTypeId != null) {
-        const keyType = describeType(meta.lookup, s.keyTypeId);
-        typeSuffix = `: ${keyType} → ${valueType}    [map]`;
-      } else {
-        typeSuffix = `: ${valueType}`;
+      const isMap = s.keyTypeId != null;
+      const tag = isMap ? `${DIM} [map]${RESET}` : "";
+      console.log(`  ${CYAN}${s.name}${RESET}${tag}`);
+      if (isMap) {
+        const keyType = prettyTypeById(meta.lookup, s.keyTypeId, {
+          indent: 4,
+          prefix: 5
+        });
+        console.log(`    ${DIM}Key:${RESET}   ${keyType}`);
       }
-      console.log(`  ${CYAN}${s.name}${RESET}${DIM}${typeSuffix}${RESET}`);
+      const valueType = prettyTypeById(meta.lookup, s.valueTypeId, {
+        indent: 4,
+        prefix: 7
+      });
+      console.log(`    ${DIM}Value:${RESET} ${valueType}`);
       const summary = firstSentence(s.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -5445,13 +6836,18 @@ async function handleQuery(target, keys, opts) {
         return;
       }
       const entries = await withStalenessSuggestion(chainName, clientHandle, () => storageApi.getEntries(...parsedKeys));
-      printResult(entries.map((e) => ({
+      const rows = entries.map((e) => ({
         keys: e.keyArgs,
         value: e.value
-      })), format);
+      }));
+      const text = format === "json" ? formatJson(rows) : formatPretty(rows);
+      await writeStdout(`${text}
+`);
     } else {
       const result = await withStalenessSuggestion(chainName, clientHandle, () => storageApi.getValue(...parsedKeys));
-      printResult(result, format);
+      const text = format === "json" ? formatJson(result) : formatPretty(result);
+      await writeStdout(`${text}
+`);
     }
   } finally {
     clientHandle.destroy();
@@ -5497,6 +6893,168 @@ async function parseStorageKeys(meta, palletName2, storageItem, args) {
   return Promise.all(args.map((arg) => parseTypedArg(meta, keyEntry, arg)));
 }
 
+// src/commands/rpc.ts
+init_store();
+init_output();
+init_rpc_registry();
+init_errors();
+var FAMILY_ORDER = [
+  "system",
+  "chain",
+  "state",
+  "author",
+  "payment",
+  "babe",
+  "grandpa",
+  "beefy",
+  "mmr",
+  "offchain",
+  "dev",
+  "spec",
+  "chainHead",
+  "chainSpec",
+  "transaction",
+  "archive",
+  "other"
+];
+async function getMethodList(chainName, rpcUrl, refresh) {
+  if (!refresh) {
+    const cached = await loadRpcMethods(chainName);
+    if (cached) {
+      return { methods: cached.methods, version: cached.version, fromCache: true };
+    }
+  }
+  const fresh = await fetchRpcMethods(rpcUrl);
+  await saveRpcMethods(chainName, fresh.methods, fresh.version);
+  return { methods: fresh.methods, version: fresh.version, fromCache: false };
+}
+function groupByFamily(methods) {
+  const groups = new Map;
+  for (const m of methods) {
+    const family = RPC_REGISTRY[m]?.family ?? inferFamily(m);
+    const list = groups.get(family) ?? [];
+    list.push(m);
+    groups.set(family, list);
+  }
+  for (const list of groups.values())
+    list.sort();
+  return groups;
+}
+function formatArgs(info) {
+  if (info.args.length === 0)
+    return "(no args)";
+  return info.args.map((a) => `<${a.name}: ${a.type}${a.optional ? "?" : ""}>`).join(" ");
+}
+function printMethodHelp(method, info) {
+  console.log();
+  console.log(`${BOLD}${method}${RESET}`);
+  if (info) {
+    if (info.dangerous) {
+      console.log(`  ${YELLOW}⚠️  WRITE / state-changing${RESET}`);
+    }
+    if (info.subscription) {
+      console.log(`  ${DIM}subscription — not callable as a one-shot${RESET}`);
+    }
+    console.log(`  ${info.description}`);
+    console.log();
+    console.log(`  ${DIM}Family:${RESET} ${info.family}`);
+    console.log(`  ${DIM}Args:${RESET}   ${formatArgs(info)}`);
+    if (info.args.some((a) => a.description)) {
+      console.log();
+      for (const a of info.args) {
+        if (a.description) {
+          console.log(`    ${CYAN}${a.name}${RESET}  ${DIM}${a.description}${RESET}`);
+        }
+      }
+    }
+  } else {
+    console.log(`  ${DIM}No curated metadata. Args are passed through as raw JSON-RPC params.${RESET}`);
+    console.log(`  ${DIM}Family:${RESET} ${inferFamily(method)} (inferred)`);
+  }
+  console.log();
+}
+async function listMethods(chainName, rpcUrl, opts) {
+  const { methods, version: version2, fromCache } = await getMethodList(chainName, rpcUrl, opts.refresh ?? false);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      version: version2,
+      fromCache,
+      methods: methods.map((m) => {
+        const info = RPC_REGISTRY[m];
+        return {
+          method: m,
+          family: info?.family ?? inferFamily(m),
+          description: info?.description,
+          dangerous: info?.dangerous ?? false,
+          subscription: info?.subscription ?? false
+        };
+      })
+    }));
+    return;
+  }
+  printHeading(`RPC methods on ${chainName} (${methods.length})`);
+  const groups = groupByFamily(methods);
+  for (const family of FAMILY_ORDER) {
+    const list = groups.get(family);
+    if (!list || list.length === 0)
+      continue;
+    console.log(`${BOLD}${family}${RESET} ${DIM}(${list.length})${RESET}`);
+    for (const m of list) {
+      const info = RPC_REGISTRY[m];
+      const tags = [];
+      if (info?.dangerous)
+        tags.push(`${YELLOW}⚠ write${RESET}`);
+      if (info?.subscription)
+        tags.push(`${DIM}sub${RESET}`);
+      const suffix = tags.length > 0 ? ` ${tags.join(" ")}` : "";
+      const desc = info?.description ? `  ${DIM}${info.description}${RESET}` : "";
+      console.log(`  ${CYAN}${m}${RESET}${suffix}${desc}`);
+    }
+    console.log();
+  }
+  if (!fromCache) {
+    console.log(`${DIM}(fetched from node — cached for next run)${RESET}`);
+  }
+}
+async function handleRpc(method, args, opts) {
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const rpcUrl = opts.rpc ?? chainConfig.rpc;
+  if (!rpcUrl) {
+    throw new CliError(`No RPC endpoint for chain "${chainName}". Pass --rpc or run \`dot chain add ${chainName} --rpc <url>\`.`);
+  }
+  if (!method) {
+    await listMethods(chainName, rpcUrl, opts);
+    return;
+  }
+  const info = RPC_REGISTRY[method];
+  if (opts.help) {
+    printMethodHelp(method, info);
+    return;
+  }
+  const { methods: knownMethods } = await getMethodList(chainName, rpcUrl, opts.refresh ?? false);
+  if (!knownMethods.includes(method)) {
+    const hint = suggestMessage("method", method, knownMethods);
+    throw new CliError(`Method "${method}" is not exposed by the node for "${chainName}".${hint ? ` ${hint}` : ""} ` + `Run \`dot ${chainName}.rpc --refresh\` if the node has been upgraded.`);
+  }
+  if (info?.subscription) {
+    throw new CliError(`"${method}" is a subscription method (requires a follow session) and is not callable as a one-shot. ` + `Use a long-running client for streaming RPC.`);
+  }
+  if (!info && /(_subscribe|_unsubscribe)/.test(method)) {
+    throw new CliError(`"${method}" looks like a subscription/unsubscription method and isn't supported as a one-shot. ` + `Pass --help to see what we know about it.`);
+  }
+  if (info) {
+    const required = info.args.filter((a) => !a.optional).length;
+    if (args.length < required) {
+      throw new CliError(`"${method}" expects at least ${required} argument(s) (${formatArgs(info)}); got ${args.length}.`);
+    }
+  }
+  const params = args.map(parseValue);
+  const result = await rpcRequest(rpcUrl, method, params);
+  printResult(result, isJsonOutput(opts) ? "json" : opts.output);
+}
+
 // src/commands/sign.ts
 init_accounts();
 init_hash();
@@ -5598,6 +7156,7 @@ init_accounts();
 init_client();
 init_metadata();
 init_output();
+init_pretty_type();
 init_resolve_address();
 init_binary_display();
 init_errors();
@@ -5730,8 +7289,11 @@ async function handleTx(target, args, opts) {
     }
     printHeading(`${pallet2.name} Calls`);
     for (const c of pallet2.calls) {
-      const callArgs = describeCallArgs(meta, pallet2.name, c.name);
-      console.log(`  ${CYAN}${c.name}${RESET}${DIM}${callArgs}${RESET}`);
+      const callArgs = prettyCallArgs(meta, pallet2.name, c.name, {
+        indent: 2,
+        prefix: c.name.length
+      });
+      console.log(`  ${CYAN}${c.name}${RESET}${callArgs}`);
       const summary = firstSentence(c.docs);
       if (summary) {
         console.log(`      ${DIM}${summary}${RESET}`);
@@ -5882,6 +7444,7 @@ async function handleTx(target, args, opts) {
       callHex = Binary3.toHex(encodedCall);
     }
     const decodedStr = decodeCall(meta, callHex);
+    const decodedObj = decodeCallObject(meta, callHex);
     if (opts.dryRun && opts.unsigned) {
       if (isJsonOutput(opts)) {
         console.log(formatJson({
@@ -5896,7 +7459,7 @@ async function handleTx(target, args, opts) {
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}Type:${RESET}   unsigned (bare)`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
-      console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
+      printDecodedCall(decodedObj, decodedStr);
       console.log(`  ${BOLD}Fees:${RESET}   ${DIM}N/A (unsigned transaction)${RESET}`);
       return;
     }
@@ -5935,7 +7498,7 @@ async function handleTx(target, args, opts) {
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
-      console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
+      printDecodedCall(decodedObj, decodedStr);
       if (nonce !== undefined)
         console.log(`  ${BOLD}Nonce:${RESET} ${nonce}`);
       if (tip !== undefined)
@@ -6012,7 +7575,7 @@ async function handleTx(target, args, opts) {
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}Type:${RESET}   unsigned (bare)`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
-      console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
+      printDecodedCall(decodedObj, decodedStr);
       console.log(`  ${BOLD}Tx:${RESET}     ${result2.txHash}`);
       if (result2.type === "broadcasted") {
         console.log(`  ${BOLD}Status:${RESET} ${GREEN}broadcasted${RESET}`);
@@ -6091,7 +7654,7 @@ async function handleTx(target, args, opts) {
     console.log();
     console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
     console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
-    console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
+    printDecodedCall(decodedObj, decodedStr);
     if (nonce !== undefined)
       console.log(`  ${BOLD}Nonce:${RESET} ${nonce}`);
     if (tip !== undefined)
@@ -6178,6 +7741,39 @@ function decodeCall(meta, callHex) {
     return "(unable to decode)";
   }
 }
+function decodeCallObject(meta, callHex) {
+  try {
+    const callTypeId = meta.lookup.call;
+    if (callTypeId == null)
+      return null;
+    const codec = meta.builder.buildDefinition(callTypeId);
+    const decoded = codec.dec(Binary3.fromHex(callHex));
+    return {
+      palletName: decoded.type,
+      callName: decoded.value.type,
+      args: sanitizeForSerialization(decoded.value.value)
+    };
+  } catch {
+    return null;
+  }
+}
+function printDecodedCall(obj, fallback) {
+  if (!obj) {
+    console.log(`  ${BOLD}Decode:${RESET} ${fallback}`);
+    return;
+  }
+  const header = `${CYAN}${obj.palletName}${RESET}.${CYAN}${obj.callName}${RESET}`;
+  const hasArgs = obj.args !== null && obj.args !== undefined && !(typeof obj.args === "object" && Object.keys(obj.args).length === 0);
+  if (!hasArgs) {
+    console.log(`  ${BOLD}Decode:${RESET} ${header}`);
+    return;
+  }
+  console.log(`  ${BOLD}Decode:${RESET} ${header}`);
+  const indented = formatPretty(obj.args).split(`
+`).map((l) => `    ${l}`).join(`
+`);
+  console.log(indented);
+}
 function decodeCallFallback(meta, callHex) {
   const callTypeId = meta.lookup.call;
   if (callTypeId == null)
@@ -7321,13 +8917,13 @@ function isNewerVersion(current, latest) {
   return compareSemver(current, latest) < 0;
 }
 function buildNotificationBox(current, latest) {
-  const YELLOW2 = "\x1B[33m";
-  const GREEN2 = "\x1B[32m";
-  const CYAN2 = "\x1B[36m";
-  const RESET2 = "\x1B[0m";
+  const YELLOW3 = "\x1B[33m";
+  const GREEN3 = "\x1B[32m";
+  const CYAN3 = "\x1B[36m";
+  const RESET3 = "\x1B[0m";
   const BOLD2 = "\x1B[1m";
-  const line1 = `Update available! ${YELLOW2}${current}${RESET2} → ${GREEN2}${BOLD2}${latest}${RESET2}`;
-  const line2 = `Run ${CYAN2}npm i -g polkadot-cli${RESET2} to update`;
+  const line1 = `Update available! ${YELLOW3}${current}${RESET3} → ${GREEN3}${BOLD2}${latest}${RESET3}`;
+  const line2 = `Run ${CYAN3}npm i -g polkadot-cli${RESET3} to update`;
   const visibleLine1 = `Update available! ${current} → ${latest}`;
   const visibleLine2 = `Run npm i -g polkadot-cli to update`;
   const innerWidth = Math.max(visibleLine1.length, visibleLine2.length) + 4;
@@ -7458,7 +9054,8 @@ var CATEGORY_ALIASES = {
   api: "apis",
   extensions: "extensions",
   extension: "extensions",
-  ext: "extensions"
+  ext: "extensions",
+  rpc: "rpc"
 };
 function matchCategory(segment) {
   return CATEGORY_ALIASES[segment.toLowerCase()];
@@ -7473,7 +9070,7 @@ function parseDotPath(input, knownChains = []) {
       const cat = matchCategory(parts[0]);
       if (cat)
         return { category: cat };
-      throw new Error(`Unknown command "${parts[0]}". Expected a category (query, tx, const, events, errors, apis, extensions) or a named command.`);
+      throw new Error(`Unknown command "${parts[0]}". Expected a category (query, tx, const, events, errors, apis, extensions, rpc) or a named command.`);
     }
     case 2: {
       const cat = matchCategory(parts[0]);
@@ -7555,6 +9152,7 @@ if (process.argv[2] === "__complete") {
     console.log("  errors    List or inspect pallet errors");
     console.log("  apis      Browse and call runtime APIs");
     console.log("  extensions  List transaction extensions on a chain");
+    console.log("  rpc       Call raw JSON-RPC methods on a node");
     console.log();
     console.log("Examples:");
     console.log("  dot polkadot.query.System.Account <addr>            Query a storage item");
@@ -7567,6 +9165,8 @@ if (process.argv[2] === "__complete") {
     console.log("  dot metadata polkadot                               Dump runtime metadata as JSON");
     console.log("  dot polkadot.extensions                             List transaction extensions");
     console.log("  dot polkadot.extensions.CheckMortality              Inspect one extension");
+    console.log("  dot polkadot.rpc                                    List RPC methods on the node");
+    console.log("  dot polkadot.rpc.system_health                      Call a JSON-RPC method");
     console.log("  dot query.System.Number --chain polkadot            --chain flag form");
     console.log("  dot ./transfer.yaml --from alice                    Run from file (chain in YAML)");
     console.log("  dot tx.0x1f0003... --to-yaml --chain polkadot       Decode hex call to YAML");
@@ -7580,7 +9180,7 @@ if (process.argv[2] === "__complete") {
     console.log("  account            Manage accounts");
     console.log("  hash               Hash utilities");
     console.log("  sign               Sign a message with an account keypair");
-    console.log("  parachain          Derive parachain sovereign accounts");
+    console.log("  parachain          Derive parachain sovereign accounts (deprecated \u2014 use `account inspect --parachain`)");
     console.log("  verifiable         Derive Bandersnatch member key from mnemonic");
     console.log("  completions <sh>   Generate shell completions (zsh, bash, fish)");
     console.log();
@@ -7611,7 +9211,7 @@ if (process.argv[2] === "__complete") {
   registerVerifiableCommands(cli);
   cli.command("[dotpath] [...args]").option("--from <name>", "Account to sign with (for tx)").option("--dry-run", "Estimate fees without submitting (for tx)").option("--encode", "Encode call to hex without signing (for tx)").option("--to-yaml", "Decode call to YAML file format (for tx)").option("--to-json", "Decode call to JSON file format (for tx)").option("--ext <json>", "Custom signed extension values as JSON (for tx)").option("--asset <json>", "Pay fees in an alternative asset (XCM location JSON, for tx)").option("-w, --wait <level>", "Resolve at: broadcast, best-block (or best), finalized (for tx)", {
     default: "finalized"
-  }).option("--dump", "Dump all entries of a storage map (without specifying a key)").option("--var <kv>", "Template variable for file input (KEY=VALUE, repeatable)").option("--nonce <n>", "Custom nonce for manual tx sequencing (for tx)").option("--tip <amount>", "Tip to prioritize transaction (for tx)").option("--mortality <spec>", '"immortal" or period number (for tx)').option("--at <block>", 'Block hash, "best", or "finalized" to validate against (for tx)').option("--unsigned", "Submit as unsigned/bare transaction (no signer required, for tx)").action(async (dotpath, args, opts) => {
+  }).option("--dump", "Dump all entries of a storage map (without specifying a key)").option("--var <kv>", "Template variable for file input (KEY=VALUE, repeatable)").option("--nonce <n>", "Custom nonce for manual tx sequencing (for tx)").option("--tip <amount>", "Tip to prioritize transaction (for tx)").option("--mortality <spec>", '"immortal" or period number (for tx)').option("--at <block>", 'Block hash, "best", or "finalized" to validate against (for tx)').option("--unsigned", "Submit as unsigned/bare transaction (no signer required, for tx)").option("--refresh", "Refresh the cached RPC method list from the node (for rpc)").action(async (dotpath, args, opts) => {
     if (!dotpath) {
       printHelp();
       return;
@@ -7674,9 +9274,10 @@ if (process.argv[2] === "__complete") {
     } catch {
       throw new CliError2(`Unknown command "${dotpath}". Run "dot --help" for available commands.`);
     }
+    const isFlatCategory = parsed.category === "rpc" || parsed.category === "extensions";
     if (!parsed.pallet && args.length > 0) {
       parsed.pallet = args.shift();
-      if (!parsed.item && args.length > 0) {
+      if (!isFlatCategory && !parsed.item && args.length > 0) {
         parsed.item = args.shift();
       }
     }
@@ -7743,6 +9344,18 @@ if (process.argv[2] === "__complete") {
         await handleExtensions(parsed.pallet, handlerOpts);
         break;
       }
+      case "rpc": {
+        if (parsed.item) {
+          const suggestion = parsed.chain ? `dot ${parsed.chain}.rpc.${parsed.pallet}` : opts.chain ? `dot rpc.${parsed.pallet} --chain ${opts.chain}` : `dot rpc.${parsed.pallet} --chain <chain>`;
+          throw new CliError2(`RPC methods have no sub-items. Try "${suggestion}".`);
+        }
+        await handleRpc(parsed.pallet, args, {
+          ...handlerOpts,
+          help: cli.options.help,
+          refresh: opts.refresh
+        });
+        break;
+      }
     }
   });
   cli.option("--help, -h", "Display this message");