polkadot-cli 1.12.0 → 1.14.0

package/dist/cli.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -15,7 +14,29 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/errors.ts
+var CliError, ConnectionError, MetadataError;
+var init_errors = __esm(() => {
+  CliError = class CliError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CliError";
+    }
+  };
+  ConnectionError = class ConnectionError extends CliError {
+    constructor(message) {
+      super(message);
+      this.name = "ConnectionError";
+    }
+  };
+  MetadataError = class MetadataError extends CliError {
+    constructor(message) {
+      super(message);
+      this.name = "MetadataError";
+    }
+  };
+});
 
 // src/config/types.ts
 function primaryRpc(rpc) {
@@ -24,7 +45,6 @@ function primaryRpc(rpc) {
 var DEFAULT_CONFIG, BUILTIN_CHAIN_NAMES;
 var init_types = __esm(() => {
   DEFAULT_CONFIG = {
-    defaultChain: "polkadot",
     chains: {
       polkadot: {
         rpc: [
@@ -53,7 +73,9 @@ var init_types = __esm(() => {
           "wss://statemint-rpc-tn.dwellir.com",
           "wss://statemint.public.curie.radiumblock.co/ws",
           "wss://asset-hub-polkadot.rpc.permanence.io"
-        ]
+        ],
+        relay: "polkadot",
+        parachainId: 1000
       },
       "polkadot-bridge-hub": {
         rpc: [
@@ -65,7 +87,9 @@ var init_types = __esm(() => {
           "wss://bridgehub-polkadot.api.onfinality.io/public-ws",
           "wss://polkadot-bridge-hub-rpc-tn.dwellir.com",
           "wss://bridgehub-polkadot.public.curie.radiumblock.co/ws"
-        ]
+        ],
+        relay: "polkadot",
+        parachainId: 1002
       },
       "polkadot-collectives": {
         rpc: [
@@ -77,7 +101,9 @@ var init_types = __esm(() => {
           "wss://collectives.api.onfinality.io/public-ws",
           "wss://polkadot-collectives-rpc-tn.dwellir.com",
           "wss://collectives.public.curie.radiumblock.co/ws"
-        ]
+        ],
+        relay: "polkadot",
+        parachainId: 1001
       },
       "polkadot-coretime": {
         rpc: [
@@ -87,7 +113,9 @@ var init_types = __esm(() => {
           "wss://coretime-polkadot-rpc.n.dwellir.com",
           "wss://rpc-coretime-polkadot.luckyfriday.io",
           "wss://coretime-polkadot.api.onfinality.io/public-ws"
-        ]
+        ],
+        relay: "polkadot",
+        parachainId: 1005
       },
       "polkadot-people": {
         rpc: [
@@ -97,7 +125,9 @@ var init_types = __esm(() => {
           "wss://people-polkadot-rpc.n.dwellir.com",
           "wss://rpc-people-polkadot.luckyfriday.io",
           "wss://people-polkadot.api.onfinality.io/public-ws"
-        ]
+        ],
+        relay: "polkadot",
+        parachainId: 1004
       },
       paseo: {
         rpc: [
@@ -113,23 +143,33 @@ var init_types = __esm(() => {
           "wss://asset-hub-paseo.dotters.network",
           "wss://asset-hub-paseo-rpc.n.dwellir.com",
           "wss://sys.turboflakes.io/asset-hub-paseo"
-        ]
+        ],
+        relay: "paseo",
+        parachainId: 1000
       },
       "paseo-bridge-hub": {
-        rpc: ["wss://bridge-hub-paseo.ibp.network", "wss://bridge-hub-paseo.dotters.network"]
+        rpc: ["wss://bridge-hub-paseo.ibp.network", "wss://bridge-hub-paseo.dotters.network"],
+        relay: "paseo",
+        parachainId: 1002
       },
       "paseo-collectives": {
-        rpc: ["wss://collectives-paseo.ibp.network", "wss://collectives-paseo.dotters.network"]
+        rpc: ["wss://collectives-paseo.ibp.network", "wss://collectives-paseo.dotters.network"],
+        relay: "paseo",
+        parachainId: 1001
       },
       "paseo-coretime": {
-        rpc: ["wss://coretime-paseo.ibp.network", "wss://coretime-paseo.dotters.network"]
+        rpc: ["wss://coretime-paseo.ibp.network", "wss://coretime-paseo.dotters.network"],
+        relay: "paseo",
+        parachainId: 1005
       },
       "paseo-people": {
         rpc: [
           "wss://people-paseo.ibp.network",
           "wss://people-paseo.dotters.network",
           "wss://people-paseo.rpc.amforc.com"
-        ]
+        ],
+        relay: "paseo",
+        parachainId: 1004
       }
     }
   };
@@ -164,10 +204,16 @@ async function loadConfig() {
   await ensureDir(DOT_DIR);
   if (await fileExists(CONFIG_PATH)) {
     const saved = JSON.parse(await readFile(CONFIG_PATH, "utf-8"));
-    return {
-      ...saved,
-      chains: { ...DEFAULT_CONFIG.chains, ...saved.chains }
-    };
+    const chains = {};
+    for (const [name, defaultConfig] of Object.entries(DEFAULT_CONFIG.chains)) {
+      chains[name] = saved.chains[name] ? { ...defaultConfig, ...saved.chains[name] } : defaultConfig;
+    }
+    for (const [name, config] of Object.entries(saved.chains)) {
+      if (!(name in DEFAULT_CONFIG.chains)) {
+        chains[name] = config;
+      }
+    }
+    return { chains };
   }
   await saveConfig(DEFAULT_CONFIG);
   return DEFAULT_CONFIG;
@@ -199,16 +245,19 @@ function findChainName(config, input) {
   return Object.keys(config.chains).find((k) => k.toLowerCase() === input.toLowerCase());
 }
 function resolveChain(config, chainFlag) {
-  const input = chainFlag ?? config.defaultChain;
-  const name = findChainName(config, input);
+  const available = Object.keys(config.chains).join(", ");
+  if (!chainFlag) {
+    throw new CliError(`No chain specified. Pass --chain <name> or use a dotpath prefix (e.g. "dot polkadot.query.System.Number"). Available chains: ${available}`);
+  }
+  const name = findChainName(config, chainFlag);
   if (!name) {
-    const available = Object.keys(config.chains).join(", ");
-    throw new Error(`Unknown chain "${input}". Available chains: ${available}`);
+    throw new CliError(`Unknown chain "${chainFlag}". Available chains: ${available}`);
   }
   return { name, chain: config.chains[name] };
 }
 var DOT_DIR, CONFIG_PATH, CHAINS_DIR;
 var init_store = __esm(() => {
+  init_errors();
   init_types();
   DOT_DIR = join(homedir(), ".polkadot");
   CONFIG_PATH = join(DOT_DIR, "config.json");
@@ -259,6 +308,42 @@ function isWatchOnly(account) {
   return account.secret === undefined;
 }
 
+// src/utils/fuzzy-match.ts
+function levenshtein(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  const dp = Array.from({ length: la + 1 }, () => Array(lb + 1).fill(0));
+  for (let i = 0;i <= la; i++)
+    dp[i][0] = i;
+  for (let j = 0;j <= lb; j++)
+    dp[0][j] = j;
+  for (let i = 1;i <= la; i++) {
+    for (let j = 1;j <= lb; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[la][lb];
+}
+function findClosest(input, candidates, maxDistance = 3) {
+  const lower = input.toLowerCase();
+  const exact = candidates.find((c) => c.toLowerCase() === lower);
+  if (exact)
+    return [exact];
+  const scored = candidates.map((c) => ({ name: c, dist: levenshtein(lower, c.toLowerCase()) })).filter((s) => s.dist <= maxDistance).sort((a, b) => a.dist - b.dist);
+  return scored.slice(0, 3).map((s) => s.name);
+}
+function suggestMessage(kind, input, candidates) {
+  const suggestions = findClosest(input, candidates);
+  if (suggestions.length === 0) {
+    return `Unknown ${kind} "${input}".`;
+  }
+  if (suggestions.length === 1 && suggestions[0]?.toLowerCase() === input.toLowerCase()) {
+    return suggestions[0];
+  }
+  return `Unknown ${kind} "${input}". Did you mean: ${suggestions.join(", ")}?`;
+}
+
 // src/core/accounts.ts
 import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import {
@@ -369,8 +454,14 @@ async function resolveAccountKeypair(name) {
   const accountsFile = await loadAccounts();
   const account = findAccount(accountsFile, name);
   if (!account) {
-    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)];
-    throw new Error(`Unknown account "${name}". Available accounts: ${available.join(", ")}`);
+    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
+    const suggestions = findClosest(name, available);
+    const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+    const list = available.map((a) => `
+    - ${a}`).join("");
+    throw new Error(`Unknown account "${name}".${hint}
+  Available accounts:${list}`);
   }
   if (account.secret === undefined) {
     throw new Error(`Account "${name}" is watch-only (no secret). Cannot sign. Import with --secret or --env.`);
@@ -390,6 +481,7 @@ var init_accounts = __esm(() => {
 });
 
 // src/utils/binary-display.ts
+import { Binary } from "polkadot-api";
 function isReadableText(text) {
   for (let i = 0;i < text.length; i++) {
     const code = text.charCodeAt(i);
@@ -407,20 +499,17 @@ function isReadableText(text) {
   return true;
 }
 function binaryToDisplay(value) {
-  const text = value.asText();
-  return isReadableText(text) ? text : value.asHex();
+  const text = Binary.toText(value);
+  return isReadableText(text) ? text : Binary.toHex(value);
 }
+var init_binary_display = () => {};
 
 // src/core/output.ts
-import { Binary } from "polkadot-api";
 function replacer(_key, value) {
   if (typeof value === "bigint")
     return value.toString();
-  if (value instanceof Binary) {
-    return binaryToDisplay(value);
-  }
   if (value instanceof Uint8Array)
-    return `0x${Buffer.from(value).toString("hex")}`;
+    return binaryToDisplay(value);
   return value;
 }
 function formatJson(data) {
@@ -442,6 +531,12 @@ function printResult(data, format = "pretty") {
     console.log(formatPretty(data));
   }
 }
+function isJsonOutput(opts) {
+  return opts.json === true || opts.output === "json";
+}
+function printJsonLine(data) {
+  console.log(JSON.stringify(data, replacer));
+}
 function printHeading(text) {
   console.log(`
 ${BOLD}${text}${RESET}
@@ -500,6 +595,7 @@ function firstSentence(docs) {
 }
 var isTTY, RESET, CYAN, GREEN, RED, YELLOW, MAGENTA, DIM, BOLD, CHECK_MARK = "✓", SPINNER_FRAMES;
 var init_output = __esm(() => {
+  init_binary_display();
   isTTY = process.stdout.isTTY ?? false;
   RESET = isTTY ? "\x1B[0m" : "";
   CYAN = isTTY ? "\x1B[36m" : "";
@@ -531,62 +627,35 @@ function deriveBandersnatchMember(mnemonic, context) {
 }
 var init_bandersnatch = () => {};
 
-// src/utils/errors.ts
-var CliError, ConnectionError, MetadataError;
-var init_errors = __esm(() => {
-  CliError = class CliError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "CliError";
-    }
-  };
-  ConnectionError = class ConnectionError extends CliError {
-    constructor(message) {
-      super(message);
-      this.name = "ConnectionError";
-    }
-  };
-  MetadataError = class MetadataError extends CliError {
-    constructor(message) {
-      super(message);
-      this.name = "MetadataError";
-    }
-  };
-});
-
 // src/core/client.ts
 import { createClient } from "polkadot-api";
-import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
-import { getWsProvider } from "polkadot-api/ws-provider";
-import { WebSocket } from "ws";
-function suppressWsNoise() {
-  const orig = console.error;
+import { getWsProvider } from "polkadot-api/ws";
+function suppressProviderNoise() {
+  const origError = console.error;
+  const origWarn = console.warn;
   console.error = (...args) => {
     if (typeof args[0] === "string" && args[0].includes("Unable to connect"))
       return;
-    orig(...args);
+    origError(...args);
+  };
+  console.warn = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("ChainHead"))
+      return;
+    origWarn(...args);
   };
   return () => {
-    console.error = orig;
+    console.error = origError;
+    console.warn = origWarn;
   };
 }
 async function createChainClient(chainName, chainConfig, rpcOverride) {
-  const useLight = !rpcOverride && chainConfig.lightClient;
-  const restoreConsole = suppressWsNoise();
-  let provider;
-  if (useLight) {
-    provider = await createSmoldotProvider(chainName);
-  } else {
-    const rpc = rpcOverride ?? chainConfig.rpc;
-    if (!rpc) {
-      restoreConsole();
-      throw new ConnectionError(`No RPC endpoint configured for chain "${chainName}". Use --rpc or configure one with: dot chain add ${chainName} --rpc <url>`);
-    }
-    provider = withPolkadotSdkCompat(getWsProvider(rpc, {
-      timeout: 1e4,
-      websocketClass: WebSocket
-    }));
+  const restoreConsole = suppressProviderNoise();
+  const rpc = rpcOverride ?? chainConfig.rpc;
+  if (!rpc) {
+    restoreConsole();
+    throw new ConnectionError(`No RPC endpoint configured for chain "${chainName}". Use --rpc or configure one with: dot chain add ${chainName} --rpc <url>`);
   }
+  const provider = getWsProvider(rpc, { timeout: 1e4 });
   const client = createClient(provider, {
     getMetadata: async () => loadMetadata(chainName),
     setMetadata: async (_codeHash, metadata) => {
@@ -596,51 +665,25 @@ async function createChainClient(chainName, chainConfig, rpcOverride) {
   return {
     client,
     destroy: () => {
-      client.destroy();
-      restoreConsole();
+      try {
+        client.destroy();
+      } catch {}
+      setTimeout(restoreConsole, 500);
     }
   };
 }
-async function createSmoldotProvider(chainName) {
-  const { start } = await import("polkadot-api/smoldot");
-  const { getSmProvider } = await import("polkadot-api/sm-provider");
-  const entry = KNOWN_CHAIN_SPECS[chainName];
-  if (!entry) {
-    throw new ConnectionError(`Light client is only supported for known chains: ${Object.keys(KNOWN_CHAIN_SPECS).join(", ")}. Use --rpc to connect to "${chainName}" instead.`);
-  }
-  const { chainSpec } = await import(entry.spec);
-  const smoldot = start();
-  if (entry.relay) {
-    const relayEntry = KNOWN_CHAIN_SPECS[entry.relay];
-    if (!relayEntry) {
-      throw new ConnectionError(`Relay chain "${entry.relay}" not found in known chain specs.`);
-    }
-    const { chainSpec: relaySpec } = await import(relayEntry.spec);
-    const relayChain = await smoldot.addChain({ chainSpec: relaySpec, disableJsonRpc: true });
-    const chain2 = await smoldot.addChain({ chainSpec, potentialRelayChains: [relayChain] });
-    return getSmProvider(chain2);
-  }
-  const chain = await smoldot.addChain({ chainSpec });
-  return getSmProvider(chain);
-}
-var KNOWN_CHAIN_SPECS;
+async function getParachainId(clientHandle) {
+  try {
+    const unsafeApi = clientHandle.client.getUnsafeApi();
+    const parachainId = await unsafeApi.query.ParachainInfo.ParachainId.getValue();
+    return typeof parachainId === "number" ? parachainId : null;
+  } catch {
+    return null;
+  }
+}
 var init_client = __esm(() => {
   init_store();
   init_errors();
-  KNOWN_CHAIN_SPECS = {
-    polkadot: { spec: "polkadot-api/chains/polkadot" },
-    kusama: { spec: "polkadot-api/chains/ksmcc3" },
-    westend: { spec: "polkadot-api/chains/westend2" },
-    paseo: { spec: "polkadot-api/chains/paseo" },
-    "polkadot-asset-hub": { spec: "polkadot-api/chains/polkadot_asset_hub", relay: "polkadot" },
-    "polkadot-bridge-hub": { spec: "polkadot-api/chains/polkadot_bridge_hub", relay: "polkadot" },
-    "polkadot-collectives": { spec: "polkadot-api/chains/polkadot_collectives", relay: "polkadot" },
-    "polkadot-coretime": { spec: "polkadot-api/chains/polkadot_coretime", relay: "polkadot" },
-    "polkadot-people": { spec: "polkadot-api/chains/polkadot_people", relay: "polkadot" },
-    "paseo-asset-hub": { spec: "polkadot-api/chains/paseo_asset_hub", relay: "paseo" },
-    "paseo-coretime": { spec: "polkadot-api/chains/paseo_coretime", relay: "paseo" },
-    "paseo-people": { spec: "polkadot-api/chains/paseo_people", relay: "paseo" }
-  };
 });
 
 // src/core/metadata.ts
@@ -915,42 +958,6 @@ var init_metadata = __esm(() => {
   v15Arg = toHex(u32.enc(15));
 });
 
-// src/utils/fuzzy-match.ts
-function levenshtein(a, b) {
-  const la = a.length;
-  const lb = b.length;
-  const dp = Array.from({ length: la + 1 }, () => Array(lb + 1).fill(0));
-  for (let i = 0;i <= la; i++)
-    dp[i][0] = i;
-  for (let j = 0;j <= lb; j++)
-    dp[0][j] = j;
-  for (let i = 1;i <= la; i++) {
-    for (let j = 1;j <= lb; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
-    }
-  }
-  return dp[la][lb];
-}
-function findClosest(input, candidates, maxDistance = 3) {
-  const lower = input.toLowerCase();
-  const exact = candidates.find((c) => c.toLowerCase() === lower);
-  if (exact)
-    return [exact];
-  const scored = candidates.map((c) => ({ name: c, dist: levenshtein(lower, c.toLowerCase()) })).filter((s) => s.dist <= maxDistance).sort((a, b) => a.dist - b.dist);
-  return scored.slice(0, 3).map((s) => s.name);
-}
-function suggestMessage(kind, input, candidates) {
-  const suggestions = findClosest(input, candidates);
-  if (suggestions.length === 0) {
-    return `Unknown ${kind} "${input}".`;
-  }
-  if (suggestions.length === 1 && suggestions[0]?.toLowerCase() === input.toLowerCase()) {
-    return suggestions[0];
-  }
-  return `Unknown ${kind} "${input}". Did you mean: ${suggestions.join(", ")}?`;
-}
-
 // src/core/explorers.ts
 var pjsAppsLink = (rpc, hash) => `https://polkadot.js.org/apps/?rpc=${encodeURIComponent(rpc)}#/explorer/query/${hash}`, papiLink = (rpc, hash) => `https://dev.papi.how/explorer/${hash}#networkId=custom&endpoint=${encodeURIComponent(rpc)}`;
 
@@ -976,9 +983,14 @@ async function resolveAccountAddress(input) {
     return input;
   }
   const stored = accountsFile.accounts.map((a) => a.name);
-  const available = [...DEV_NAMES, ...stored];
-  throw new Error(`Unknown account or address "${input}".
-  Available accounts: ${available.join(", ")}`);
+  const available = [...DEV_NAMES, ...stored].sort((a, b) => a.localeCompare(b));
+  const suggestions = findClosest(input, available);
+  const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+  const list = available.map((a) => `
+    - ${a}`).join("");
+  throw new Error(`Unknown account or address "${input}".${hint}
+  Available accounts:${list}`);
 }
 var init_resolve_address = __esm(() => {
   init_accounts_store();
@@ -1006,6 +1018,7 @@ function parseValue(arg) {
 }
 
 // src/commands/tx.ts
+import { compact as scaleCompact } from "@polkadot-api/substrate-bindings";
 import { getViewBuilder } from "@polkadot-api/view-builder";
 import { Binary as Binary2 } from "polkadot-api";
 import { stringify as stringifyYaml } from "yaml";
@@ -1206,7 +1219,7 @@ async function parseTypedArg(meta, entry, arg) {
     case "enum": {
       if (/^0x[0-9a-fA-F]+$/.test(arg) && meta.lookup.call != null && entry.id === meta.lookup.call) {
         const callCodec = meta.builder.buildDefinition(meta.lookup.call);
-        return callCodec.dec(Binary2.fromHex(arg).asBytes());
+        return callCodec.dec(Binary2.fromHex(arg));
       }
       if (arg.startsWith("{")) {
         try {
@@ -1318,6 +1331,7 @@ var init_tx = __esm(() => {
   init_metadata();
   init_output();
   init_resolve_address();
+  init_binary_display();
   init_errors();
   init_focused_inspect();
   PAPI_BUILTIN_EXTENSIONS = new Set([
@@ -1348,6 +1362,13 @@ async function handleApis(target, args, opts) {
     const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const apis = listRuntimeApis(meta);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        apis: apis.map((a) => ({ name: a.name, methods: a.methods.length }))
+      }));
+      return;
+    }
     printHeading(`Runtime APIs on ${chainName2} (${apis.length})`);
     for (const api of apis) {
       printItem(api.name, `${api.methods.length} methods`);
@@ -1370,7 +1391,24 @@ async function handleApis(target, args, opts) {
     const meta = await loadMeta(chainName, chainConfig, opts.rpc);
     const api = resolveRuntimeApi(meta, apiName);
     if (api.methods.length === 0) {
-      console.log(`No methods in ${api.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, api: api.name, methods: [] }));
+      } else {
+        console.log(`No methods in ${api.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        api: api.name,
+        methods: api.methods.map((m) => ({
+          name: m.name,
+          args: describeRuntimeApiMethodArgs(meta, m),
+          returns: describeType(meta.lookup, m.output),
+          docs: firstSentence(m.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${api.name} Methods`);
@@ -1401,7 +1439,7 @@ async function handleApis(target, args, opts) {
     const parsedArgs = await parseRuntimeApiArgs(meta, method, effectiveArgs);
     const unsafeApi = clientHandle.client.getUnsafeApi();
     const result = await unsafeApi.apis[api.name][method.name](...parsedArgs);
-    const format = opts.output ?? "pretty";
+    const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     printResult(result, format);
   } finally {
     clientHandle.destroy();
@@ -1438,11 +1476,23 @@ var init_apis = __esm(() => {
 
 // src/commands/focused-inspect.ts
 async function loadMeta(chainName, chainConfig, rpcOverride) {
+  if (rpcOverride) {
+    process.stderr.write(`Fetching metadata from ${chainName}...
+`);
+    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    try {
+      const raw = await fetchMetadataFromChain(clientHandle, chainName);
+      return parseMetadata(raw);
+    } finally {
+      clientHandle.destroy();
+    }
+  }
   try {
     return await getOrFetchMetadata(chainName);
   } catch {
-    console.error(`Fetching metadata from ${chainName}...`);
-    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    process.stderr.write(`Fetching metadata from ${chainName}...
+`);
+    const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       return await getOrFetchMetadata(chainName, clientHandle);
     } finally {
@@ -1465,6 +1515,13 @@ async function handleCalls(target, opts) {
     const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withCalls = pallets.filter((p) => p.calls.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withCalls.map((p) => ({ name: p.name, calls: p.calls.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
     for (const p of withCalls) {
       printItem(p.name, `${p.calls.length} calls`);
@@ -1481,7 +1538,23 @@ async function handleCalls(target, opts) {
   const pallet = resolvePallet(meta, palletName);
   if (!itemName) {
     if (pallet.calls.length === 0) {
-      console.log(`No calls in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, calls: [] }));
+      } else {
+        console.log(`No calls in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        calls: pallet.calls.map((c) => ({
+          name: c.name,
+          args: describeCallArgs(meta, pallet.name, c.name),
+          docs: firstSentence(c.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Calls`);
@@ -1501,6 +1574,17 @@ async function handleCalls(target, opts) {
     const names = pallet.calls.map((c) => c.name);
     throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: callItem.name,
+      category: "call",
+      args: describeCallArgs(meta, pallet.name, callItem.name),
+      docs: callItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${callItem.name} (Call)`);
   const args = describeCallArgs(meta, pallet.name, callItem.name);
   console.log(`  ${BOLD}Args:${RESET} ${args}`);
@@ -1517,6 +1601,13 @@ async function handleEvents(target, opts) {
     const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withEvents = pallets.filter((p) => p.events.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withEvents.map((p) => ({ name: p.name, events: p.events.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with events on ${chainName2} (${withEvents.length})`);
     for (const p of withEvents) {
       printItem(p.name, `${p.events.length} events`);
@@ -1533,7 +1624,23 @@ async function handleEvents(target, opts) {
   const pallet = resolvePallet(meta, palletName);
   if (!itemName) {
     if (pallet.events.length === 0) {
-      console.log(`No events in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, events: [] }));
+      } else {
+        console.log(`No events in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        events: pallet.events.map((e) => ({
+          name: e.name,
+          fields: describeEventFields(meta, pallet.name, e.name),
+          docs: firstSentence(e.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Events`);
@@ -1553,6 +1660,17 @@ async function handleEvents(target, opts) {
     const names = pallet.events.map((e) => e.name);
     throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: eventItem.name,
+      category: "event",
+      fields: describeEventFields(meta, pallet.name, eventItem.name),
+      docs: eventItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${eventItem.name} (Event)`);
   const fields = describeEventFields(meta, pallet.name, eventItem.name);
   console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
@@ -1569,6 +1687,13 @@ async function handleErrors(target, opts) {
     const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withErrors = pallets.filter((p) => p.errors.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withErrors.map((p) => ({ name: p.name, errors: p.errors.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with errors on ${chainName2} (${withErrors.length})`);
     for (const p of withErrors) {
       printItem(p.name, `${p.errors.length} errors`);
@@ -1585,7 +1710,19 @@ async function handleErrors(target, opts) {
   const pallet = resolvePallet(meta, palletName);
   if (!itemName) {
     if (pallet.errors.length === 0) {
-      console.log(`No errors in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, errors: [] }));
+      } else {
+        console.log(`No errors in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        errors: pallet.errors.map((e) => ({ name: e.name, docs: firstSentence(e.docs) }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Errors`);
@@ -1604,6 +1741,16 @@ async function handleErrors(target, opts) {
     const names = pallet.errors.map((e) => e.name);
     throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: errorItem.name,
+      category: "error",
+      docs: errorItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${errorItem.name} (Error)`);
   if (errorItem.docs.length) {
     printDocs(errorItem.docs);
@@ -1617,6 +1764,13 @@ async function handleStorage(target, opts) {
     const meta2 = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withStorage = pallets.filter((p) => p.storage.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withStorage.map((p) => ({ name: p.name, storage: p.storage.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
     for (const p of withStorage) {
       printItem(p.name, `${p.storage.length} storage`);
@@ -1633,7 +1787,23 @@ async function handleStorage(target, opts) {
   const pallet = resolvePallet(meta, palletName);
   if (!itemName) {
     if (pallet.storage.length === 0) {
-      console.log(`No storage items in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, storage: [] }));
+      } else {
+        console.log(`No storage items in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        storage: pallet.storage.map((s) => {
+          const valueType = 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;
     }
     printHeading(`${pallet.name} Storage`);
@@ -1660,6 +1830,21 @@ async function handleStorage(target, opts) {
     const names = pallet.storage.map((s) => s.name);
     throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    const valueType = describeType(meta.lookup, storageItem.valueTypeId);
+    const keyType = storageItem.keyTypeId != null ? describeType(meta.lookup, storageItem.keyTypeId) : undefined;
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: storageItem.name,
+      category: "storage",
+      type: storageItem.type,
+      valueType,
+      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)}`);
@@ -1998,6 +2183,9 @@ async function generateCompletions(currentWord, precedingWords) {
   if (prevWord === "--wait" || prevWord === "-w") {
     return filterPrefix(["broadcast", "best-block", "best", "finalized"], currentWord);
   }
+  if (prevWord === "--relay") {
+    return filterPrefix(knownChains, currentWord);
+  }
   if (currentWord.startsWith("--")) {
     const activeCategory = detectCategory(precedingWords, knownChains);
     const options = [...GLOBAL_OPTIONS];
@@ -2005,10 +2193,19 @@ async function generateCompletions(currentWord, precedingWords) {
       options.push(...TX_OPTIONS);
     if (activeCategory === "query")
       options.push(...QUERY_OPTIONS);
+    const chainIdx = precedingWords.indexOf("chain");
+    if (chainIdx >= 0 && precedingWords[chainIdx + 1] === "add") {
+      options.push("--relay", "--parachain-id");
+    }
     return filterPrefix(options, currentWord);
   }
   const firstArg = precedingWords.find((w) => !w.startsWith("-"));
   if (firstArg === "chain") {
+    const chainSubIdx = precedingWords.indexOf("chain");
+    const subcommand = precedingWords[chainSubIdx + 1];
+    if (subcommand === "add" && currentWord.startsWith("--")) {
+      return filterPrefix(["--rpc", "--relay", "--parachain-id", ...GLOBAL_OPTIONS], currentWord);
+    }
     return filterPrefix(CHAIN_SUBCOMMANDS, currentWord);
   }
   if (firstArg === "account") {
@@ -2062,7 +2259,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
       return completeApisCategory(first, numComplete, endsWithDot, completeSegments, currentWord, config, chainFromFlag);
     }
     if (numComplete === 1 && endsWithDot) {
-      const chainName = chainFromFlag ?? config.defaultChain;
+      const chainName = chainFromFlag;
+      if (!chainName)
+        return [];
       const pallets = await loadPallets(config, chainName);
       if (!pallets)
         return [];
@@ -2071,7 +2270,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
       return filterPrefix(candidates, currentWord.slice(0, -1));
     }
     if (numComplete === 1 && !endsWithDot) {
-      const chainName = chainFromFlag ?? config.defaultChain;
+      const chainName = chainFromFlag;
+      if (!chainName)
+        return [];
       const pallets = await loadPallets(config, chainName);
       if (!pallets)
         return [];
@@ -2081,7 +2282,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
     }
     if (numComplete === 2) {
       const palletName2 = completeSegments[1];
-      const chainName = chainFromFlag ?? config.defaultChain;
+      const chainName = chainFromFlag;
+      if (!chainName)
+        return [];
       const pallets = await loadPallets(config, chainName);
       if (!pallets)
         return [];
@@ -2143,7 +2346,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
   return [];
 }
 async function completeApisCategory(prefix, numComplete, endsWithDot, segments, currentWord, config, chainNameOverride) {
-  const chainName = chainNameOverride ?? config.defaultChain;
+  const chainName = chainNameOverride;
+  if (!chainName)
+    return [];
   const apis = await loadRuntimeApiNames(config, chainName);
   if (!apis)
     return [];
@@ -2187,7 +2392,7 @@ var init_complete = __esm(() => {
     api: "apis"
   };
   NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "parachain", "completions"];
-  CHAIN_SUBCOMMANDS = ["add", "remove", "update", "list", "default"];
+  CHAIN_SUBCOMMANDS = ["add", "remove", "update", "list"];
   ACCOUNT_SUBCOMMANDS = [
     "add",
     "create",
@@ -2199,9 +2404,10 @@ var init_complete = __esm(() => {
     "delete",
     "inspect"
   ];
-  GLOBAL_OPTIONS = ["--chain", "--rpc", "--light-client", "--output", "--help", "--version"];
+  GLOBAL_OPTIONS = ["--chain", "--rpc", "--output", "--help", "--version"];
   TX_OPTIONS = [
     "--from",
+    "--unsigned",
     "--dry-run",
     "--encode",
     "--ext",
@@ -2217,12 +2423,13 @@ var init_complete = __esm(() => {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "1.12.0";
+var version = "1.14.0";
 
 // src/commands/account.ts
 init_accounts_store();
 init_accounts();
 init_output();
+import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
 var ACCOUNT_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot account add <name> <ss58|hex>                                Add a watch-only address (no secret)
@@ -2231,6 +2438,8 @@ ${BOLD}Usage:${RESET}
   $ dot account create|new <name> [--path <derivation>]              Create a new account
   $ dot account import <name> --secret <s> [--path <derivation>]     Import from BIP39 mnemonic
   $ dot account import <name> --env <VAR> [--path <derivation>]      Import account backed by env variable
+  $ dot account import --file <path>                                 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>]                       Inspect an account/address/key
   $ dot account list                                                 List all accounts
@@ -2243,6 +2452,13 @@ ${BOLD}Examples:${RESET}
   $ dot account create multi --path //polkadot//0/wallet
   $ dot account import treasury --secret "word1 word2 ... word12"
   $ dot account import ci-signer --env MY_SECRET --path //ci
+  $ dot account import --file team-accounts.json
+  $ dot account import --file accounts.json --dry-run
+  $ dot account import --file accounts.json --overwrite
+  $ dot account export
+  $ dot account export treasury my-validator
+  $ dot account export --include-secrets --file backup.json
+  $ dot account export --watch-only
   $ dot account derive treasury treasury-staking --path //staking
   $ dot account inspect alice
   $ dot account inspect 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
@@ -2255,10 +2471,10 @@ ${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)").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)").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("--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").action(async (action, names, opts) => {
     if (!action) {
       if (process.argv[2] === "accounts")
-        return accountList();
+        return accountList(opts);
       console.log(ACCOUNT_HELP);
       return;
     }
@@ -2269,16 +2485,20 @@ function registerAccountCommands(cli) {
       case "add":
         if (opts.secret || opts.env)
           return accountImport(names[0], opts);
-        return accountAddWatchOnly(names[0], names[1]);
+        return accountAddWatchOnly(names[0], names[1], opts);
       case "import":
+        if (opts.file)
+          return accountBatchImport(opts);
         return accountImport(names[0], opts);
+      case "export":
+        return accountExport(names, opts);
       case "derive":
         return accountDerive(names[0], names[1], opts);
       case "list":
-        return accountList();
+        return accountList(opts);
       case "delete":
       case "remove":
-        return accountRemove(names);
+        return accountRemove(names, opts);
       case "inspect":
         return accountInspect(names[0], opts);
       default:
@@ -2316,6 +2536,18 @@ async function accountCreate(name, opts) {
     bandersnatch
   });
   await saveAccounts(accountsFile);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      name,
+      address,
+      publicKey: hexPub,
+      mnemonic,
+      path: path || undefined,
+      bandersnatch
+    }));
+    console.error(`Save this mnemonic phrase! It is the only way to recover this account.`);
+    return;
+  }
   printHeading("Account Created");
   console.log(`  ${BOLD}Name:${RESET}          ${name}`);
   if (path)
@@ -2364,6 +2596,11 @@ async function accountImport(name, opts) {
       derivationPath: path
     });
     await saveAccounts(accountsFile);
+    if (isJsonOutput(opts)) {
+      const address = publicKey ? toSs58(publicKey) : undefined;
+      console.log(formatJson({ name, address, env: opts.env, path: path || undefined }));
+      return;
+    }
     printHeading("Account Imported");
     console.log(`  ${BOLD}Name:${RESET}    ${name}`);
     if (path)
@@ -2386,6 +2623,10 @@ async function accountImport(name, opts) {
       derivationPath: path
     });
     await saveAccounts(accountsFile);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({ name, address, publicKey: hexPub, path: path || undefined }));
+      return;
+    }
     printHeading("Account Imported");
     console.log(`  ${BOLD}Name:${RESET}    ${name}`);
     if (path)
@@ -2394,7 +2635,7 @@ async function accountImport(name, opts) {
     console.log();
   }
 }
-async function accountAddWatchOnly(name, address) {
+async function accountAddWatchOnly(name, address, opts = {}) {
   if (!name) {
     console.error(`Account name is required.
 `);
@@ -2431,6 +2672,10 @@ async function accountAddWatchOnly(name, address) {
     derivationPath: ""
   });
   await saveAccounts(accountsFile);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ name, address: toSs58(hexPub), watchOnly: true }));
+    return;
+  }
   printHeading("Account Added (watch-only)");
   console.log(`  ${BOLD}Name:${RESET}    ${name}`);
   console.log(`  ${BOLD}Address:${RESET} ${toSs58(hexPub)}`);
@@ -2480,6 +2725,11 @@ async function accountDerive(sourceName, newName, opts) {
       derivationPath: path
     });
     await saveAccounts(accountsFile);
+    if (isJsonOutput(opts)) {
+      const address = publicKey ? toSs58(publicKey) : undefined;
+      console.log(formatJson({ name: newName, source: sourceName, path, address, env: sourceSecret.env }));
+      return;
+    }
     printHeading("Account Derived");
     console.log(`  ${BOLD}Name:${RESET}    ${newName}`);
     console.log(`  ${BOLD}Source:${RESET}  ${sourceName}`);
@@ -2502,6 +2752,10 @@ async function accountDerive(sourceName, newName, opts) {
       derivationPath: path
     });
     await saveAccounts(accountsFile);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({ name: newName, source: sourceName, path, address, publicKey: hexPub }));
+      return;
+    }
     printHeading("Account Derived");
     console.log(`  ${BOLD}Name:${RESET}    ${newName}`);
     console.log(`  ${BOLD}Source:${RESET}  ${sourceName}`);
@@ -2510,14 +2764,43 @@ async function accountDerive(sourceName, newName, opts) {
     console.log();
   }
 }
-async function accountList() {
+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)
+    }));
+    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 {
+        name: account.name,
+        address,
+        derivationPath: account.derivationPath || undefined,
+        watchOnly: isWatchOnly(account),
+        env: account.secret !== undefined && isEnvSecret(account.secret) ? account.secret.env : undefined
+      };
+    });
+    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 accountsFile = await loadAccounts();
   if (accountsFile.accounts.length > 0) {
     printHeading("Stored Accounts");
     for (const account of accountsFile.accounts) {
@@ -2547,7 +2830,7 @@ async function accountList() {
   }
   console.log();
 }
-async function accountRemove(names) {
+async function accountRemove(names, opts = {}) {
   if (names.length === 0) {
     console.error(`At least one account name is required.
 `);
@@ -2582,6 +2865,10 @@ async function accountRemove(names) {
     accountsFile.accounts.splice(idx, 1);
   }
   await saveAccounts(accountsFile);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ removed: names }));
+    return;
+  }
   for (const name of names) {
     console.log(`Account "${name}" removed.`);
   }
@@ -2637,7 +2924,7 @@ async function accountInspect(input, opts) {
     }
   }
   const ss58 = toSs58(publicKeyHex, prefix);
-  if (opts.output === "json") {
+  if (isJsonOutput(opts)) {
     const result = { publicKey: publicKeyHex, ss58, prefix };
     if (name)
       result.name = name;
@@ -2666,6 +2953,162 @@ async function accountInspect(input, opts) {
     console.log();
   }
 }
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+var REDACTED = "<redacted>";
+async function accountExport(names, opts) {
+  const accountsFile = await loadAccounts();
+  if (opts.includeSecrets) {
+    process.stderr.write(`${YELLOW}Warning: secrets are included in the export.${RESET}
+`);
+  }
+  let accounts = accountsFile.accounts;
+  if (names.length > 0) {
+    const filtered = [];
+    for (const input of names) {
+      const account = findAccount(accountsFile, input);
+      if (!account) {
+        throw new Error(`Account "${input}" not found.`);
+      }
+      filtered.push(account);
+    }
+    accounts = filtered;
+  }
+  if (opts.watchOnly) {
+    accounts = accounts.filter((a) => isWatchOnly(a));
+  }
+  const exported = accounts.map((account) => {
+    const entry = {
+      name: account.name,
+      publicKey: account.publicKey,
+      derivationPath: account.derivationPath
+    };
+    if (isWatchOnly(account)) {} else if (account.secret !== undefined && isEnvSecret(account.secret)) {
+      entry.secret = account.secret;
+    } else if (opts.includeSecrets) {
+      entry.secret = account.secret;
+    } else {
+      entry.secret = REDACTED;
+    }
+    if (account.bandersnatch && Object.keys(account.bandersnatch).length > 0) {
+      entry.bandersnatch = account.bandersnatch;
+    }
+    return entry;
+  });
+  const exportData = { accounts: exported };
+  const json = `${JSON.stringify(exportData, null, 2)}
+`;
+  if (opts.file) {
+    await writeFile3(opts.file, json);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({ action: "exported", file: opts.file, count: exported.length }));
+    } else {
+      console.log(`Exported ${exported.length} account(s) to ${opts.file}`);
+    }
+  } else {
+    process.stdout.write(json);
+  }
+}
+async function accountBatchImport(opts) {
+  let raw;
+  if (!opts.file || opts.file === "-") {
+    raw = await readStdin();
+  } else {
+    raw = await readFile3(opts.file, "utf-8");
+  }
+  let importData;
+  try {
+    importData = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid JSON input.");
+  }
+  if (!Array.isArray(importData.accounts)) {
+    throw new Error('Invalid import format: missing "accounts" array.');
+  }
+  const accountsFile = await loadAccounts();
+  const added = [];
+  const skipped = [];
+  const overwritten = [];
+  for (const entry of importData.accounts) {
+    if (!entry.name) {
+      process.stderr.write(`${YELLOW}Skipped entry with missing name.${RESET}
+`);
+      continue;
+    }
+    if (isDevAccount(entry.name)) {
+      process.stderr.write(`${YELLOW}Skipped "${entry.name}": built-in dev account.${RESET}
+`);
+      skipped.push(entry.name);
+      continue;
+    }
+    const existing = findAccount(accountsFile, entry.name);
+    if (existing && !opts.overwrite) {
+      skipped.push(entry.name);
+      process.stderr.write(`${YELLOW}Skipped "${entry.name}": already exists (use --overwrite to replace)${RESET}
+`);
+      continue;
+    }
+    const stored = {
+      name: entry.name,
+      publicKey: entry.publicKey || "",
+      derivationPath: entry.derivationPath || ""
+    };
+    if (entry.secret === undefined || entry.secret === REDACTED) {} else if (typeof entry.secret === "object" && "env" in entry.secret) {
+      stored.secret = entry.secret;
+      if (!stored.publicKey) {
+        stored.publicKey = tryDerivePublicKey(entry.secret.env, stored.derivationPath) ?? "";
+      }
+    } else if (typeof entry.secret === "string") {
+      stored.secret = entry.secret;
+      try {
+        const { publicKey } = importAccount(entry.secret, stored.derivationPath);
+        stored.publicKey = publicKeyToHex(publicKey);
+      } catch {
+        process.stderr.write(`${YELLOW}Warning: "${entry.name}" has an invalid secret, importing as watch-only.${RESET}
+`);
+        delete stored.secret;
+      }
+    }
+    if (entry.bandersnatch && Object.keys(entry.bandersnatch).length > 0) {
+      stored.bandersnatch = entry.bandersnatch;
+    }
+    if (existing) {
+      const idx = accountsFile.accounts.findIndex((a) => a.name.toLowerCase() === entry.name.toLowerCase());
+      accountsFile.accounts[idx] = stored;
+      overwritten.push(entry.name);
+    } else {
+      accountsFile.accounts.push(stored);
+      added.push(entry.name);
+    }
+  }
+  if (!opts.dryRun) {
+    await saveAccounts(accountsFile);
+  }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      action: opts.dryRun ? "dry-run" : "imported",
+      added,
+      overwritten,
+      skipped
+    }));
+    return;
+  }
+  const prefix = opts.dryRun ? "(dry run) " : "";
+  if (added.length > 0)
+    console.log(`${prefix}Added: ${added.join(", ")}`);
+  if (overwritten.length > 0)
+    console.log(`${prefix}Overwritten: ${overwritten.join(", ")}`);
+  if (skipped.length > 0)
+    console.log(`${prefix}Skipped: ${skipped.join(", ")}`);
+  if (added.length === 0 && overwritten.length === 0) {
+    console.log(`${prefix}No accounts imported.`);
+  }
+}
 
 // src/commands/apis.ts
 init_store();
@@ -2680,6 +3123,13 @@ async function handleApis2(target, args, opts) {
     const { name: chainName2, chain: chainConfig2 } = resolveChain(config2, opts.chain);
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const apis = listRuntimeApis(meta);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        apis: apis.map((a) => ({ name: a.name, methods: a.methods.length }))
+      }));
+      return;
+    }
     printHeading(`Runtime APIs on ${chainName2} (${apis.length})`);
     for (const api of apis) {
       printItem(api.name, `${api.methods.length} methods`);
@@ -2702,7 +3152,24 @@ async function handleApis2(target, args, opts) {
     const meta = await loadMeta(chainName, chainConfig, opts.rpc);
     const api = resolveRuntimeApi2(meta, apiName);
     if (api.methods.length === 0) {
-      console.log(`No methods in ${api.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, api: api.name, methods: [] }));
+      } else {
+        console.log(`No methods in ${api.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        api: api.name,
+        methods: api.methods.map((m) => ({
+          name: m.name,
+          args: describeRuntimeApiMethodArgs(meta, m),
+          returns: describeType(meta.lookup, m.output),
+          docs: firstSentence(m.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${api.name} Methods`);
@@ -2733,7 +3200,7 @@ async function handleApis2(target, args, opts) {
     const parsedArgs = await parseRuntimeApiArgs2(meta, method, effectiveArgs);
     const unsafeApi = clientHandle.client.getUnsafeApi();
     const result = await unsafeApi.apis[api.name][method.name](...parsedArgs);
-    const format = opts.output ?? "pretty";
+    const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     printResult(result, format);
   } finally {
     clientHandle.destroy();
@@ -2766,46 +3233,54 @@ init_types();
 init_client();
 init_metadata();
 init_output();
+import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
 var CHAIN_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot chain add <name> --rpc <url>    Add a chain via WebSocket RPC
-  $ dot chain add <name> --light-client Add a chain via Smoldot light client
   $ dot chain remove <name>             Remove a chain
-  $ dot chain update [name]             Re-fetch metadata (default chain if omitted)
+  $ 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 default <name>            Set the default chain
+  $ dot chain export [names...]         Export chain configuration to stdout
+  $ dot chain import <file>             Import chain configuration from a file
 
 ${BOLD}Examples:${RESET}
   $ dot chain add kusama --rpc wss://kusama-rpc.polkadot.io
   $ dot chain add kusama --rpc wss://kusama-rpc.polkadot.io --rpc wss://kusama-rpc.dwellir.com
-  $ dot chain add westend --light-client
-  $ dot chain default kusama
+  $ 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 chain update
   $ dot chain update kusama
   $ dot chain update --all
   $ dot chain remove kusama
+  $ dot chain export
+  $ dot chain export my-relay my-para --file my-chains.json
+  $ dot chain export --all
+  $ dot chain import my-chains.json
+  $ dot chain import my-chains.json --dry-run
+  $ dot chain import my-chains.json --overwrite
 `.trimStart();
 function registerChainCommands(cli) {
-  cli.command("chain [action] [name]", "Manage chains (add, remove, update, list, default)").alias("chains").option("--all", "Update all configured chains").action(async (action, name, 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").action(async (action, names, opts) => {
     if (!action) {
       if (process.argv[2] === "chains")
-        return chainList();
+        return chainList(opts);
       console.log(CHAIN_HELP);
       return;
     }
     switch (action) {
       case "add":
-        return chainAdd(name, opts);
+        return chainAdd(names[0], opts);
       case "remove":
-        return chainRemove(name);
+        return chainRemove(names[0], opts);
       case "list":
-        return chainList();
+        return chainList(opts);
       case "update":
-        return chainUpdate(name, opts);
-      case "default":
-        return chainDefault(name);
+        return chainUpdate(names[0], opts);
+      case "export":
+        return chainExport(names, opts);
+      case "import":
+        return chainImport(names[0], opts);
       default:
         console.error(`Unknown action "${action}".
 `);
@@ -2819,34 +3294,70 @@ async function chainAdd(name, opts) {
     console.error(`Chain name is required.
 `);
     console.error("Usage: dot chain add <name> --rpc <url>");
-    console.error("       dot chain add <name> --light-client");
     process.exit(1);
   }
-  if (!opts.rpc && !opts.lightClient) {
-    console.error(`Must provide either --rpc <url> or --light-client.
+  if (!opts.rpc) {
+    console.error(`Must provide --rpc <url>.
 `);
     console.error("Usage: dot chain add <name> --rpc <url>");
-    console.error("       dot chain add <name> --light-client");
     process.exit(1);
   }
-  const chainConfig = {
-    rpc: opts.rpc ?? "",
-    ...opts.lightClient ? { lightClient: true } : {}
-  };
-  console.error(`Connecting to ${name}...`);
+  const parachainIdRaw = opts.parachainId != null ? Number(opts.parachainId) : undefined;
+  if (parachainIdRaw != null && !opts.relay) {
+    console.error(`Cannot set --parachain-id without --relay.
+`);
+    console.error("Usage: dot chain add <name> --rpc <url> --relay <relay> --parachain-id <id>");
+    process.exit(1);
+  }
+  const chainConfig = { rpc: opts.rpc };
+  process.stderr.write(`Connecting to ${name}...
+`);
   const clientHandle = await createChainClient(name, chainConfig, opts.rpc);
   try {
-    console.error("Fetching metadata...");
+    process.stderr.write(`Fetching metadata...
+`);
     await fetchMetadataFromChain(clientHandle, name);
+    if (opts.relay) {
+      const config2 = await loadConfig();
+      const relayResolved = findChainName(config2, opts.relay);
+      if (!relayResolved) {
+        throw new Error(`Relay chain "${opts.relay}" not found. Add it first with: dot chain add ${opts.relay} --rpc <url>`);
+      }
+      chainConfig.relay = relayResolved;
+      if (parachainIdRaw != null) {
+        chainConfig.parachainId = parachainIdRaw;
+      } else {
+        process.stderr.write(`Detecting parachain ID...
+`);
+        const detected = await getParachainId(clientHandle);
+        if (detected != null) {
+          chainConfig.parachainId = detected;
+          process.stderr.write(`Detected parachain ID: ${detected}
+`);
+        } else {
+          process.stderr.write(`Could not detect parachain ID. Use --parachain-id to set it manually.
+`);
+        }
+      }
+    }
     const config = await loadConfig();
     config.chains[name] = chainConfig;
     await saveConfig(config);
-    console.log(`Chain "${name}" added successfully.`);
+    const result = { action: "added", chain: name };
+    if (chainConfig.relay)
+      result.relay = chainConfig.relay;
+    if (chainConfig.parachainId != null)
+      result.parachainId = chainConfig.parachainId;
+    if (isJsonOutput(opts)) {
+      console.log(formatJson(result));
+    } else {
+      console.log(`Chain "${name}" added successfully.`);
+    }
   } finally {
     clientHandle.destroy();
   }
 }
-async function chainRemove(name) {
+async function chainRemove(name, opts = {}) {
   if (!name) {
     console.error("Usage: dot chain remove <name>");
     process.exit(1);
@@ -2859,32 +3370,77 @@ async function chainRemove(name) {
   if (BUILTIN_CHAIN_NAMES.has(resolved)) {
     throw new Error(`Cannot remove the built-in "${resolved}" chain.`);
   }
-  delete config.chains[resolved];
-  if (config.defaultChain === resolved) {
-    config.defaultChain = "polkadot";
-    console.log(`Default chain reset to "polkadot".`);
+  const orphans = Object.entries(config.chains).filter(([, c]) => c.relay === resolved).map(([n]) => n);
+  if (orphans.length > 0) {
+    console.error(`Warning: ${orphans.length} chain(s) reference "${resolved}" as their relay: ${orphans.join(", ")}`);
   }
+  delete config.chains[resolved];
   await saveConfig(config);
   await removeChainData(resolved);
-  console.log(`Chain "${resolved}" removed.`);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ action: "removed", chain: resolved }));
+  } else {
+    console.log(`Chain "${resolved}" removed.`);
+  }
 }
-async function chainList() {
+async function chainList(opts = {}) {
   const config = await loadConfig();
+  if (isJsonOutput(opts)) {
+    const chains = Object.entries(config.chains).map(([name, chainConfig]) => ({
+      name,
+      rpc: Array.isArray(chainConfig.rpc) ? chainConfig.rpc : [chainConfig.rpc],
+      ...chainConfig.relay && { relay: chainConfig.relay },
+      ...chainConfig.parachainId != null && { parachainId: chainConfig.parachainId }
+    }));
+    console.log(formatJson({ chains }));
+    return;
+  }
   printHeading("Configured Chains");
+  const parachainsByRelay = new Map;
+  const standalone = [];
   for (const [name, chainConfig] of Object.entries(config.chains)) {
-    const isDefault = name === config.defaultChain;
-    const marker = isDefault ? ` ${BOLD}(default)${RESET}` : "";
-    if (chainConfig.lightClient) {
-      console.log(`  ${CYAN}${name}${RESET}${marker}  ${DIM}light-client${RESET}`);
-    } else {
-      const rpcs = Array.isArray(chainConfig.rpc) ? chainConfig.rpc : [chainConfig.rpc];
-      console.log(`  ${CYAN}${name}${RESET}${marker}  ${DIM}${rpcs[0]}${RESET}`);
-      for (let i = 1;i < rpcs.length; i++) {
-        console.log(`    ${DIM}${rpcs[i]}${RESET}`);
-      }
+    if (chainConfig.relay) {
+      const paras = parachainsByRelay.get(chainConfig.relay) ?? [];
+      paras.push([name, chainConfig]);
+      parachainsByRelay.set(chainConfig.relay, paras);
     }
   }
-  console.log();
+  const relayNames = new Set(parachainsByRelay.keys());
+  for (const [name, chainConfig] of Object.entries(config.chains)) {
+    if (relayNames.has(name))
+      continue;
+    if (chainConfig.relay)
+      continue;
+    standalone.push([name, chainConfig]);
+  }
+  for (const relayName of relayNames) {
+    const relayConfig = config.chains[relayName];
+    if (relayConfig) {
+      printChainLine("  ", relayName, relayConfig);
+    }
+    const paras = parachainsByRelay.get(relayName) ?? [];
+    for (let i = 0;i < paras.length; i++) {
+      const [name, chainConfig] = paras[i];
+      const isLast = i === paras.length - 1;
+      const prefix = isLast ? "  └─ " : "  ├─ ";
+      const idSuffix = chainConfig.parachainId != null ? ` ${DIM}[${chainConfig.parachainId}]${RESET}` : "";
+      printChainLine(prefix, name, chainConfig, idSuffix);
+    }
+    console.log();
+  }
+  for (const [name, chainConfig] of standalone) {
+    printChainLine("  ", name, chainConfig);
+  }
+  if (standalone.length > 0)
+    console.log();
+}
+function printChainLine(prefix, name, chainConfig, suffix = "") {
+  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, " ");
+  for (let i = 1;i < rpcs.length; i++) {
+    console.log(`${indent}  ${DIM}${rpcs[i]}${RESET}`);
+  }
 }
 async function chainUpdate(name, opts) {
   const config = await loadConfig();
@@ -2892,20 +3448,31 @@ async function chainUpdate(name, opts) {
     await chainUpdateAll(config);
     return;
   }
+  if (!name) {
+    console.error("Usage: dot chain update <name> | --all");
+    process.exit(1);
+  }
   const { name: chainName, chain: chainConfig } = resolveChain(config, name);
-  console.error(`Connecting to ${chainName}...`);
+  process.stderr.write(`Connecting to ${chainName}...
+`);
   const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
   try {
-    console.error("Fetching metadata...");
+    process.stderr.write(`Fetching metadata...
+`);
     await fetchMetadataFromChain(clientHandle, chainName);
-    console.log(`Metadata for "${chainName}" updated.`);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({ action: "updated", chain: chainName }));
+    } else {
+      console.log(`Metadata for "${chainName}" updated.`);
+    }
   } finally {
     clientHandle.destroy();
   }
 }
 async function chainUpdateAll(config) {
   const chainNames = Object.keys(config.chains).sort();
-  console.error(`Updating metadata for ${chainNames.length} chains...
+  process.stderr.write(`Updating metadata for ${chainNames.length} chains...
+
 `);
   const results = await Promise.allSettled(chainNames.map(async (chainName) => {
     const chainConfig = config.chains[chainName];
@@ -2915,37 +3482,150 @@ async function chainUpdateAll(config) {
     } finally {
       clientHandle.destroy();
     }
-  }));
-  for (let i = 0;i < chainNames.length; i++) {
-    const result = results[i];
-    const name = chainNames[i];
-    if (result.status === "fulfilled") {
-      console.log(`  ${GREEN}${CHECK_MARK}${RESET} ${name}`);
+  }));
+  for (let i = 0;i < chainNames.length; i++) {
+    const result = results[i];
+    const name = chainNames[i];
+    if (result.status === "fulfilled") {
+      console.log(`  ${GREEN}${CHECK_MARK}${RESET} ${name}`);
+    } else {
+      console.log(`  ${RED}✗${RESET} ${name}${DIM} — ${result.reason?.message ?? "unknown error"}${RESET}`);
+    }
+  }
+  const failed = results.filter((r) => r.status === "rejected").length;
+  if (failed > 0) {
+    console.error(`
+${failed} of ${chainNames.length} chains failed to update.`);
+    process.exit(1);
+  }
+}
+function isBuiltinModified(name, config) {
+  const defaultRpc = DEFAULT_CONFIG.chains[name]?.rpc;
+  const currentRpc = config.chains[name]?.rpc;
+  if (!defaultRpc || !currentRpc)
+    return false;
+  return JSON.stringify(currentRpc) !== JSON.stringify(defaultRpc);
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function chainExport(names, opts) {
+  const config = await loadConfig();
+  const exportChains = {};
+  if (names.length > 0) {
+    for (const input of names) {
+      const resolved = findChainName(config, input);
+      if (!resolved) {
+        throw new Error(`Chain "${input}" not found.`);
+      }
+      exportChains[resolved] = config.chains[resolved];
+    }
+  } else if (opts.all) {
+    Object.assign(exportChains, config.chains);
+  } else {
+    for (const [name, chainConfig] of Object.entries(config.chains)) {
+      if (!BUILTIN_CHAIN_NAMES.has(name) || isBuiltinModified(name, config)) {
+        exportChains[name] = chainConfig;
+      }
+    }
+  }
+  const exportData = {
+    chains: exportChains
+  };
+  const json = `${JSON.stringify(exportData, null, 2)}
+`;
+  if (opts.file) {
+    await writeFile4(opts.file, json);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        action: "exported",
+        file: opts.file,
+        count: Object.keys(exportChains).length
+      }));
+    } else {
+      console.log(`Exported ${Object.keys(exportChains).length} chain(s) to ${opts.file}`);
+    }
+  } else {
+    process.stdout.write(json);
+  }
+}
+async function chainImport(filePath, opts) {
+  const inputPath = filePath ?? opts.file;
+  let raw;
+  if (inputPath && inputPath !== "-") {
+    raw = await readFile4(inputPath, "utf-8");
+  } else {
+    raw = await readStdin2();
+  }
+  let importData;
+  try {
+    importData = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid JSON input.");
+  }
+  if (!importData.chains || typeof importData.chains !== "object") {
+    throw new Error('Invalid import format: missing "chains" object.');
+  }
+  const config = await loadConfig();
+  const added = [];
+  const skipped = [];
+  const overwritten = [];
+  const warnings = [];
+  for (const [name, chainConfig] of Object.entries(importData.chains)) {
+    const existing = findChainName(config, name);
+    if (existing && !opts.overwrite) {
+      skipped.push(existing);
+      process.stderr.write(`${YELLOW}Skipped "${existing}": already exists (use --overwrite to replace)${RESET}
+`);
+      continue;
+    }
+    if (chainConfig.relay) {
+      const relayInImport = Object.keys(importData.chains).some((n) => n.toLowerCase() === chainConfig.relay.toLowerCase());
+      const relayInConfig = findChainName(config, chainConfig.relay);
+      if (!relayInImport && !relayInConfig) {
+        warnings.push(`Chain "${name}" references relay "${chainConfig.relay}" which does not exist.`);
+        process.stderr.write(`${YELLOW}Warning: "${name}" references relay "${chainConfig.relay}" which does not exist.${RESET}
+`);
+      }
+    }
+    if (existing) {
+      overwritten.push(existing);
+      config.chains[existing] = chainConfig;
     } else {
-      console.log(`  ${RED}✗${RESET} ${name}${DIM} — ${result.reason?.message ?? "unknown error"}${RESET}`);
+      added.push(name);
+      config.chains[name] = chainConfig;
     }
   }
-  const failed = results.filter((r) => r.status === "rejected").length;
-  if (failed > 0) {
-    console.error(`
-${failed} of ${chainNames.length} chains failed to update.`);
-    process.exit(1);
+  if (!opts.dryRun) {
+    await saveConfig(config);
   }
-}
-async function chainDefault(name) {
-  if (!name) {
-    console.error("Usage: dot chain default <name>");
-    process.exit(1);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      action: opts.dryRun ? "dry-run" : "imported",
+      added,
+      overwritten,
+      skipped,
+      warnings
+    }));
+    return;
   }
-  const config = await loadConfig();
-  const resolved = findChainName(config, name);
-  if (!resolved) {
-    const available = Object.keys(config.chains).join(", ");
-    throw new Error(`Chain "${name}" not found. Available: ${available}`);
+  const prefix = opts.dryRun ? "(dry run) " : "";
+  if (added.length > 0)
+    console.log(`${prefix}Added: ${added.join(", ")}`);
+  if (overwritten.length > 0)
+    console.log(`${prefix}Overwritten: ${overwritten.join(", ")}`);
+  if (skipped.length > 0)
+    console.log(`${prefix}Skipped: ${skipped.join(", ")}`);
+  if (added.length === 0 && overwritten.length === 0) {
+    console.log(`${prefix}No chains imported.`);
+  } else if (!opts.dryRun) {
+    console.error(`
+Run "dot chain update --all" to fetch metadata for imported chains.`);
   }
-  config.defaultChain = resolved;
-  await saveConfig(config);
-  console.log(`Default chain set to "${resolved}".`);
 }
 
 // src/commands/completions.ts
@@ -3045,6 +3725,13 @@ async function handleConst(target, opts) {
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta);
     const withConsts = pallets.filter((p) => p.constants.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withConsts.map((p) => ({ name: p.name, constants: p.constants.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with constants on ${chainName2} (${withConsts.length})`);
     for (const p of withConsts) {
       printItem(p.name, `${p.constants.length} constants`);
@@ -3065,7 +3752,23 @@ async function handleConst(target, opts) {
       throw new Error(suggestMessage("pallet", pallet, palletNames));
     }
     if (palletInfo.constants.length === 0) {
-      console.log(`No constants in ${palletInfo.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: palletInfo.name, constants: [] }));
+      } else {
+        console.log(`No constants in ${palletInfo.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: palletInfo.name,
+        constants: palletInfo.constants.map((c) => ({
+          name: c.name,
+          type: describeType(meta.lookup, c.typeId),
+          docs: firstSentence(c.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${palletInfo.name} Constants`);
@@ -3094,9 +3797,9 @@ async function handleConst(target, opts) {
       throw new Error(suggestMessage(`constant in ${palletInfo.name}`, item, constNames));
     }
     const unsafeApi = clientHandle.client.getUnsafeApi();
-    const runtimeToken = await unsafeApi.runtimeToken;
-    const result = unsafeApi.constants[palletInfo.name][constantItem.name](runtimeToken);
-    const format = opts.output ?? "pretty";
+    const staticApis = await unsafeApi.getStaticApis();
+    const result = staticApis.constants[palletInfo.name][constantItem.name];
+    const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     printResult(result, format);
   } finally {
     clientHandle.destroy();
@@ -3109,11 +3812,23 @@ init_client();
 init_metadata();
 init_output();
 async function loadMeta2(chainName, chainConfig, rpcOverride) {
+  if (rpcOverride) {
+    process.stderr.write(`Fetching metadata from ${chainName}...
+`);
+    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    try {
+      const raw = await fetchMetadataFromChain(clientHandle, chainName);
+      return parseMetadata(raw);
+    } finally {
+      clientHandle.destroy();
+    }
+  }
   try {
     return await getOrFetchMetadata(chainName);
   } catch {
-    console.error(`Fetching metadata from ${chainName}...`);
-    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    process.stderr.write(`Fetching metadata from ${chainName}...
+`);
+    const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       return await getOrFetchMetadata(chainName, clientHandle);
     } finally {
@@ -3136,6 +3851,13 @@ async function handleCalls2(target, opts) {
     const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withCalls = pallets.filter((p) => p.calls.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withCalls.map((p) => ({ name: p.name, calls: p.calls.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
     for (const p of withCalls) {
       printItem(p.name, `${p.calls.length} calls`);
@@ -3152,7 +3874,23 @@ async function handleCalls2(target, opts) {
   const pallet = resolvePallet2(meta, palletName);
   if (!itemName) {
     if (pallet.calls.length === 0) {
-      console.log(`No calls in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, calls: [] }));
+      } else {
+        console.log(`No calls in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        calls: pallet.calls.map((c) => ({
+          name: c.name,
+          args: describeCallArgs(meta, pallet.name, c.name),
+          docs: firstSentence(c.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Calls`);
@@ -3172,6 +3910,17 @@ async function handleCalls2(target, opts) {
     const names = pallet.calls.map((c) => c.name);
     throw new Error(suggestMessage(`call in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: callItem.name,
+      category: "call",
+      args: describeCallArgs(meta, pallet.name, callItem.name),
+      docs: callItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${callItem.name} (Call)`);
   const args = describeCallArgs(meta, pallet.name, callItem.name);
   console.log(`  ${BOLD}Args:${RESET} ${args}`);
@@ -3188,6 +3937,13 @@ async function handleEvents2(target, opts) {
     const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withEvents = pallets.filter((p) => p.events.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withEvents.map((p) => ({ name: p.name, events: p.events.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with events on ${chainName2} (${withEvents.length})`);
     for (const p of withEvents) {
       printItem(p.name, `${p.events.length} events`);
@@ -3204,7 +3960,23 @@ async function handleEvents2(target, opts) {
   const pallet = resolvePallet2(meta, palletName);
   if (!itemName) {
     if (pallet.events.length === 0) {
-      console.log(`No events in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, events: [] }));
+      } else {
+        console.log(`No events in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        events: pallet.events.map((e) => ({
+          name: e.name,
+          fields: describeEventFields(meta, pallet.name, e.name),
+          docs: firstSentence(e.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Events`);
@@ -3224,6 +3996,17 @@ async function handleEvents2(target, opts) {
     const names = pallet.events.map((e) => e.name);
     throw new Error(suggestMessage(`event in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: eventItem.name,
+      category: "event",
+      fields: describeEventFields(meta, pallet.name, eventItem.name),
+      docs: eventItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${eventItem.name} (Event)`);
   const fields = describeEventFields(meta, pallet.name, eventItem.name);
   console.log(`  ${BOLD}Fields:${RESET} ${fields}`);
@@ -3240,6 +4023,13 @@ async function handleErrors2(target, opts) {
     const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withErrors = pallets.filter((p) => p.errors.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withErrors.map((p) => ({ name: p.name, errors: p.errors.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with errors on ${chainName2} (${withErrors.length})`);
     for (const p of withErrors) {
       printItem(p.name, `${p.errors.length} errors`);
@@ -3256,7 +4046,19 @@ async function handleErrors2(target, opts) {
   const pallet = resolvePallet2(meta, palletName);
   if (!itemName) {
     if (pallet.errors.length === 0) {
-      console.log(`No errors in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, errors: [] }));
+      } else {
+        console.log(`No errors in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        errors: pallet.errors.map((e) => ({ name: e.name, docs: firstSentence(e.docs) }))
+      }));
       return;
     }
     printHeading(`${pallet.name} Errors`);
@@ -3275,6 +4077,16 @@ async function handleErrors2(target, opts) {
     const names = pallet.errors.map((e) => e.name);
     throw new Error(suggestMessage(`error in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: errorItem.name,
+      category: "error",
+      docs: errorItem.docs
+    }));
+    return;
+  }
   printHeading(`${pallet.name}.${errorItem.name} (Error)`);
   if (errorItem.docs.length) {
     printDocs(errorItem.docs);
@@ -3288,6 +4100,13 @@ async function handleStorage2(target, opts) {
     const meta2 = await loadMeta2(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta2);
     const withStorage = pallets.filter((p) => p.storage.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withStorage.map((p) => ({ name: p.name, storage: p.storage.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
     for (const p of withStorage) {
       printItem(p.name, `${p.storage.length} storage`);
@@ -3304,7 +4123,23 @@ async function handleStorage2(target, opts) {
   const pallet = resolvePallet2(meta, palletName);
   if (!itemName) {
     if (pallet.storage.length === 0) {
-      console.log(`No storage items in ${pallet.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName, pallet: pallet.name, storage: [] }));
+      } else {
+        console.log(`No storage items in ${pallet.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName,
+        pallet: pallet.name,
+        storage: pallet.storage.map((s) => {
+          const valueType = 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;
     }
     printHeading(`${pallet.name} Storage`);
@@ -3331,6 +4166,21 @@ async function handleStorage2(target, opts) {
     const names = pallet.storage.map((s) => s.name);
     throw new Error(suggestMessage(`storage item in ${pallet.name}`, itemName, names));
   }
+  if (isJsonOutput(opts)) {
+    const valueType = describeType(meta.lookup, storageItem.valueTypeId);
+    const keyType = storageItem.keyTypeId != null ? describeType(meta.lookup, storageItem.keyTypeId) : undefined;
+    console.log(formatJson({
+      chain: chainName,
+      pallet: pallet.name,
+      item: storageItem.name,
+      category: "storage",
+      type: storageItem.type,
+      valueType,
+      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)}`);
@@ -3521,7 +4371,7 @@ async function showItemHelp2(category, target, opts) {
 init_hash();
 init_output();
 init_errors();
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 async function resolveInput(data, opts) {
   const sources = [data !== undefined, !!opts.file, !!opts.stdin].filter(Boolean).length;
   if (sources > 1) {
@@ -3531,7 +4381,7 @@ async function resolveInput(data, opts) {
     throw new CliError("No input provided. Pass data as argument, or use --file or --stdin");
   }
   if (opts.file) {
-    const buf = await readFile3(opts.file);
+    const buf = await readFile5(opts.file);
     return new Uint8Array(buf);
   }
   if (opts.stdin) {
@@ -3574,8 +4424,7 @@ function registerHashCommand(cli) {
     const input = await resolveInput(data, opts);
     const hash = computeHash(algorithm, input);
     const hexHash = toHex2(hash);
-    const format = opts.output ?? "pretty";
-    if (format === "json") {
+    if (isJsonOutput(opts)) {
       printResult({
         algorithm,
         input: data ?? (opts.file ? `file:${opts.file}` : "stdin"),
@@ -3658,19 +4507,46 @@ function registerInspectCommand(cli) {
     }
     const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
     let meta;
-    try {
-      meta = await getOrFetchMetadata(chainName);
-    } catch {
-      console.error(`Fetching metadata from ${chainName}...`);
+    if (opts.rpc) {
+      process.stderr.write(`Fetching metadata from ${chainName}...
+`);
       const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
       try {
-        meta = await getOrFetchMetadata(chainName, clientHandle);
+        const raw = await fetchMetadataFromChain(clientHandle, chainName);
+        meta = parseMetadata(raw);
       } finally {
         clientHandle.destroy();
       }
+    } else {
+      try {
+        meta = await getOrFetchMetadata(chainName);
+      } catch {
+        process.stderr.write(`Fetching metadata from ${chainName}...
+`);
+        const clientHandle = await createChainClient(chainName, chainConfig);
+        try {
+          meta = await getOrFetchMetadata(chainName, clientHandle);
+        } finally {
+          clientHandle.destroy();
+        }
+      }
     }
     if (!target) {
       const pallets = listPallets(meta);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({
+          chain: chainName,
+          pallets: pallets.map((p) => ({
+            name: p.name,
+            storage: p.storage.length,
+            constants: p.constants.length,
+            calls: p.calls.length,
+            events: p.events.length,
+            errors: p.errors.length
+          }))
+        }));
+        return;
+      }
       printHeading(`Pallets on ${chainName} (${pallets.length})`);
       for (const p of pallets) {
         const counts = [];
@@ -3695,6 +4571,44 @@ function registerInspectCommand(cli) {
       if (!pallet2) {
         throw new Error(suggestMessage("pallet", palletName, palletNames2));
       }
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet2.name,
+          docs: pallet2.docs,
+          storage: pallet2.storage.map((s) => {
+            const valueType = 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)
+            };
+          }),
+          constants: pallet2.constants.map((c) => ({
+            name: c.name,
+            type: describeType(meta.lookup, c.typeId),
+            docs: firstSentence(c.docs)
+          })),
+          calls: pallet2.calls.map((c) => ({
+            name: c.name,
+            args: describeCallArgs(meta, pallet2.name, c.name),
+            docs: firstSentence(c.docs)
+          })),
+          events: pallet2.events.map((e) => ({
+            name: e.name,
+            fields: describeEventFields(meta, pallet2.name, e.name),
+            docs: firstSentence(e.docs)
+          })),
+          errors: pallet2.errors.map((e) => ({
+            name: e.name,
+            docs: firstSentence(e.docs)
+          }))
+        }));
+        return;
+      }
       printHeading(`${pallet2.name} Pallet`);
       if (pallet2.docs.length) {
         printDocs(pallet2.docs);
@@ -3773,6 +4687,79 @@ function registerInspectCommand(cli) {
     if (!pallet) {
       throw new Error(suggestMessage("pallet", palletName, palletNames));
     }
+    if (isJsonOutput(opts)) {
+      const si = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+      if (si) {
+        const valueType = describeType(meta.lookup, si.valueTypeId);
+        const keyType = si.keyTypeId != null ? describeType(meta.lookup, si.keyTypeId) : undefined;
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet.name,
+          item: si.name,
+          category: "storage",
+          type: si.type,
+          valueType,
+          keyType,
+          docs: si.docs
+        }));
+        return;
+      }
+      const ci = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (ci) {
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet.name,
+          item: ci.name,
+          category: "constant",
+          type: describeType(meta.lookup, ci.typeId),
+          docs: ci.docs
+        }));
+        return;
+      }
+      const ca = pallet.calls.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+      if (ca) {
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet.name,
+          item: ca.name,
+          category: "call",
+          args: describeCallArgs(meta, pallet.name, ca.name),
+          docs: ca.docs
+        }));
+        return;
+      }
+      const ev = pallet.events.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (ev) {
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet.name,
+          item: ev.name,
+          category: "event",
+          fields: describeEventFields(meta, pallet.name, ev.name),
+          docs: ev.docs
+        }));
+        return;
+      }
+      const er = pallet.errors.find((e) => e.name.toLowerCase() === itemName.toLowerCase());
+      if (er) {
+        console.log(formatJson({
+          chain: chainName,
+          pallet: pallet.name,
+          item: er.name,
+          category: "error",
+          docs: er.docs
+        }));
+        return;
+      }
+      const allItems2 = [
+        ...pallet.storage.map((s) => s.name),
+        ...pallet.constants.map((c) => c.name),
+        ...pallet.calls.map((c) => c.name),
+        ...pallet.events.map((e) => e.name),
+        ...pallet.errors.map((e) => e.name)
+      ];
+      throw new Error(suggestMessage(`item in ${pallet.name}`, itemName, allItems2));
+    }
     const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
     if (storageItem) {
       printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
@@ -3906,8 +4893,7 @@ function registerParachainCommand(cli) {
       throw new CliError(`Invalid prefix "${opts.prefix}". Must be a non-negative integer.`);
     }
     const types = opts.type ? [validateType(opts.type)] : SOVEREIGN_ACCOUNT_TYPES;
-    const format = opts.output ?? "pretty";
-    if (format === "json") {
+    if (isJsonOutput(opts)) {
       const result = { paraId, prefix };
       for (const type of types) {
         const accountId = deriveSovereignAccount(paraId, type);
@@ -3948,6 +4934,13 @@ async function handleQuery(target, keys, opts) {
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta);
     const withStorage = pallets.filter((p) => p.storage.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withStorage.map((p) => ({ name: p.name, storage: p.storage.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with storage on ${chainName2} (${withStorage.length})`);
     for (const p of withStorage) {
       printItem(p.name, `${p.storage.length} storage items`);
@@ -3962,7 +4955,23 @@ async function handleQuery(target, keys, opts) {
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallet2 = resolvePallet(meta, palletName(target));
     if (pallet2.storage.length === 0) {
-      console.log(`No storage items in ${pallet2.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName2, pallet: pallet2.name, storage: [] }));
+      } else {
+        console.log(`No storage items in ${pallet2.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallet: pallet2.name,
+        storage: pallet2.storage.map((s) => {
+          const valueType = 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;
     }
     printHeading(`${pallet2.name} Storage`);
@@ -4007,7 +5016,7 @@ async function handleQuery(target, keys, opts) {
       typeof opts.parsedArgs === "object" ? JSON.stringify(opts.parsedArgs) : String(opts.parsedArgs)
     ];
     const parsedKeys = await parseStorageKeys(meta, palletInfo.name, storageItem, effectiveKeys);
-    const format = opts.output ?? "pretty";
+    const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     const expectedLen = storageItem.type === "map" && storageItem.keyTypeId != null ? meta.builder.buildStorage(palletInfo.name, storageItem.name).len : 0;
     if (storageItem.type === "map" && parsedKeys.length < expectedLen) {
       if (parsedKeys.length === 0 && !opts.dump) {
@@ -4074,7 +5083,7 @@ init_accounts();
 init_hash();
 init_output();
 init_errors();
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 var SUPPORTED_TYPES = ["sr25519"];
 function isSupportedType(type) {
   return SUPPORTED_TYPES.includes(type.toLowerCase());
@@ -4094,7 +5103,7 @@ async function resolveInput2(data, opts) {
     throw new CliError("No input provided. Pass data as argument, or use --file or --stdin");
   }
   if (opts.file) {
-    const buf = await readFile4(opts.file);
+    const buf = await readFile6(opts.file);
     return new Uint8Array(buf);
   }
   if (opts.stdin) {
@@ -4152,8 +5161,7 @@ function registerSignCommand(cli) {
       signature: hexSignature,
       enum: enumValue
     };
-    const format = opts.output ?? "pretty";
-    if (format === "json") {
+    if (isJsonOutput(opts)) {
       printResult(result, "json");
     } else {
       console.log(`  ${BOLD}Type:${RESET}       ${result.type}`);
@@ -4172,8 +5180,10 @@ init_client();
 init_metadata();
 init_output();
 init_resolve_address();
+init_binary_display();
 init_errors();
 init_focused_inspect();
+import { compact as scaleCompact2 } from "@polkadot-api/substrate-bindings";
 import { getViewBuilder as getViewBuilder2 } from "@polkadot-api/view-builder";
 import { Binary as Binary3 } from "polkadot-api";
 import { stringify as stringifyYaml2 } from "yaml";
@@ -4226,14 +5236,31 @@ function parseMortalityOption(raw) {
   }
   return { mortal: true, period: n };
 }
+function parseAssetOption(raw) {
+  if (raw === undefined)
+    return;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    throw new CliError(`Invalid --asset value: ${err.message}
+` + `Expected an XCM location, e.g. '{"parents":0,"interior":{"type":"X2","value":[{"type":"PalletInstance","value":50},{"type":"GeneralIndex","value":"3"}]}}'`);
+  }
+}
 function parseAtOption(raw) {
   if (raw === undefined)
     return;
-  if (raw === "best" || raw === "finalized")
-    return raw;
+  if (raw === "finalized")
+    return;
+  if (raw === "best") {
+    throw new CliError('"best" is no longer supported for --at in papi v2. Omit --at for finalized, or pass a specific block hash.');
+  }
   if (/^0x[0-9a-fA-F]{64}$/.test(raw))
     return raw;
-  throw new CliError(`Invalid --at value "${raw}". Use "best", "finalized", or a 0x-prefixed 32-byte block hash.`);
+  throw new CliError(`Invalid --at value "${raw}". Use a 0x-prefixed 32-byte block hash, or omit for finalized.`);
 }
 async function handleTx(target, args, opts) {
   if (!target) {
@@ -4242,6 +5269,13 @@ async function handleTx(target, args, opts) {
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallets = listPallets(meta);
     const withCalls = pallets.filter((p) => p.calls.length > 0);
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallets: withCalls.map((p) => ({ name: p.name, calls: p.calls.length }))
+      }));
+      return;
+    }
     printHeading(`Pallets with calls on ${chainName2} (${withCalls.length})`);
     for (const p of withCalls) {
       printItem(p.name, `${p.calls.length} calls`);
@@ -4256,7 +5290,23 @@ async function handleTx(target, args, opts) {
     const meta = await loadMeta(chainName2, chainConfig2, opts.rpc);
     const pallet2 = resolvePallet(meta, target);
     if (pallet2.calls.length === 0) {
-      console.log(`No calls in ${pallet2.name}.`);
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({ chain: chainName2, pallet: pallet2.name, calls: [] }));
+      } else {
+        console.log(`No calls in ${pallet2.name}.`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      console.log(formatJson({
+        chain: chainName2,
+        pallet: pallet2.name,
+        calls: pallet2.calls.map((c) => ({
+          name: c.name,
+          args: describeCallArgs(meta, pallet2.name, c.name),
+          docs: firstSentence(c.docs)
+        }))
+      }));
       return;
     }
     printHeading(`${pallet2.name} Calls`);
@@ -4271,9 +5321,9 @@ async function handleTx(target, args, opts) {
     console.log();
     return;
   }
-  if (!opts.from && !opts.encode && !opts.yaml && !opts.json) {
+  if (!opts.from && !opts.unsigned && !opts.encode && !opts.toYaml && !opts.toJson) {
     if (isRawCall) {
-      throw new Error("--from is required (or use --encode to output hex without signing)");
+      throw new Error("--from is required (or use --unsigned for bare tx, --encode for hex without signing)");
     }
     await showItemHelp("tx", target, opts);
     return;
@@ -4284,14 +5334,26 @@ async function handleTx(target, args, opts) {
   if (opts.encode && isRawCall) {
     throw new Error("--encode cannot be used with raw call hex (already encoded)");
   }
-  if ((opts.yaml || opts.json) && opts.encode) {
-    throw new Error("--yaml/--json and --encode are mutually exclusive");
+  if ((opts.toYaml || opts.toJson) && opts.encode) {
+    throw new Error("--to-yaml/--to-json and --encode are mutually exclusive");
+  }
+  if ((opts.toYaml || opts.toJson) && opts.dryRun) {
+    throw new Error("--to-yaml/--to-json and --dry-run are mutually exclusive");
   }
-  if ((opts.yaml || opts.json) && opts.dryRun) {
-    throw new Error("--yaml/--json and --dry-run are mutually exclusive");
+  if (opts.toYaml && opts.toJson) {
+    throw new Error("--to-yaml and --to-json are mutually exclusive");
   }
-  if (opts.yaml && opts.json) {
-    throw new Error("--yaml and --json are mutually exclusive");
+  if (opts.unsigned && opts.from) {
+    throw new Error("--unsigned and --from are mutually exclusive");
+  }
+  if (opts.unsigned && opts.nonce) {
+    throw new Error("--unsigned does not support --nonce");
+  }
+  if (opts.unsigned && opts.tip) {
+    throw new Error("--unsigned does not support --tip");
+  }
+  if (opts.unsigned && opts.mortality) {
+    throw new Error("--unsigned does not support --mortality");
   }
   const config = await loadConfig();
   const effectiveChain = opts.chain;
@@ -4303,10 +5365,10 @@ async function handleTx(target, args, opts) {
     callName = target.slice(dotIdx + 1);
   }
   const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
-  const decodeOnly = opts.encode || opts.yaml || opts.json;
-  const signer = decodeOnly ? undefined : await resolveAccountSigner(opts.from);
+  const decodeOnly = opts.encode || opts.toYaml || opts.toJson;
+  const signer = decodeOnly || opts.unsigned ? undefined : await resolveAccountSigner(opts.from);
   let clientHandle;
-  if (!decodeOnly) {
+  if (!decodeOnly || opts.unsigned) {
     clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
   }
   try {
@@ -4325,11 +5387,18 @@ async function handleTx(target, args, opts) {
     let txOptions;
     const nonce = parseNonceOption(opts.nonce);
     const tip = parseTipOption(opts.tip);
+    const asset = parseAssetOption(opts.asset);
     const mortality = parseMortalityOption(opts.mortality);
     const at = parseAtOption(opts.at);
-    if (!decodeOnly) {
+    if (!decodeOnly || opts.unsigned) {
       const userExtOverrides = parseExtOption(opts.ext);
-      const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
+      const skipBuiltins = asset !== undefined ? new Set([...PAPI_BUILTIN_EXTENSIONS2].filter((e) => e !== "ChargeAssetTxPayment")) : PAPI_BUILTIN_EXTENSIONS2;
+      if (asset !== undefined) {
+        userExtOverrides.ChargeAssetTxPayment ??= {
+          value: { tip: tip ?? 0n, asset_id: asset }
+        };
+      }
+      const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides, skipBuiltins);
       const built = {};
       if (Object.keys(customSignedExtensions).length > 0)
         built.customSignedExtensions = customSignedExtensions;
@@ -4352,9 +5421,9 @@ async function handleTx(target, args, opts) {
 ` + "Usage: dot tx 0x<call_hex> --from <account>");
       }
       callHex = target;
-      if (opts.yaml || opts.json) {
+      if (opts.toYaml || opts.toJson) {
         const fileObj = decodeCallToFileFormat(meta, callHex, chainName);
-        outputFileFormat(fileObj, !!opts.yaml);
+        outputFileFormat(fileObj, !!opts.toYaml);
         return;
       }
       const callBinary = Binary3.fromHex(target);
@@ -4372,26 +5441,75 @@ async function handleTx(target, args, opts) {
       }
       const effectiveArgs = opts.parsedArgs !== undefined ? fileArgsToStrings(opts.parsedArgs) : args;
       const callData = await parseCallArgs(meta, palletInfo.name, callInfo.name, effectiveArgs);
-      if (opts.encode || opts.yaml || opts.json) {
+      if (opts.encode && !opts.unsigned || opts.toYaml || opts.toJson) {
         const { codec, location } = meta.builder.buildCall(palletInfo.name, callInfo.name);
         const encodedArgs = codec.enc(callData);
         const fullCall = new Uint8Array([location[0], location[1], ...encodedArgs]);
-        const hex = Binary3.fromBytes(fullCall).asHex();
+        const hex = Binary3.toHex(fullCall);
         if (opts.encode) {
-          console.log(hex);
+          if (isJsonOutput(opts)) {
+            console.log(formatJson({ callHex: hex }));
+          } else {
+            console.log(hex);
+          }
           return;
         }
         const fileObj = decodeCallToFileFormat(meta, hex, chainName);
-        outputFileFormat(fileObj, !!opts.yaml);
+        outputFileFormat(fileObj, !!opts.toYaml);
         return;
       }
       tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
       const encodedCall = await tx.getEncodedData();
-      callHex = encodedCall.asHex();
+      callHex = Binary3.toHex(encodedCall);
     }
     const decodedStr = decodeCall(meta, callHex);
+    if (opts.dryRun && opts.unsigned) {
+      if (isJsonOutput(opts)) {
+        console.log(formatJson({
+          chain: chainName,
+          unsigned: true,
+          callHex,
+          decoded: decodedStr,
+          estimatedFees: null
+        }));
+        return;
+      }
+      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}`);
+      console.log(`  ${BOLD}Fees:${RESET}   ${DIM}N/A (unsigned transaction)${RESET}`);
+      return;
+    }
     if (opts.dryRun) {
       const signerAddress = toSs58(signer.publicKey);
+      let estimatedFees;
+      try {
+        estimatedFees = String(await tx.getEstimatedFees(signer?.publicKey, txOptions));
+      } catch {
+        estimatedFees = undefined;
+      }
+      if (isJsonOutput(opts)) {
+        const result2 = {
+          chain: chainName,
+          from: { name: opts.from, address: signerAddress },
+          callHex,
+          decoded: decodedStr,
+          estimatedFees
+        };
+        if (nonce !== undefined)
+          result2.nonce = nonce;
+        if (tip !== undefined)
+          result2.tip = String(tip);
+        if (asset !== undefined)
+          result2.asset = asset;
+        if (mortality !== undefined)
+          result2.mortality = mortality.mortal ? `mortal (period ${mortality.period})` : "immortal";
+        if (at !== undefined)
+          result2.at = at;
+        console.log(formatJson(result2));
+        return;
+      }
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
@@ -4400,20 +5518,147 @@ async function handleTx(target, args, opts) {
         console.log(`  ${BOLD}Nonce:${RESET} ${nonce}`);
       if (tip !== undefined)
         console.log(`  ${BOLD}Tip:${RESET}   ${tip}`);
+      if (asset !== undefined)
+        console.log(`  ${BOLD}Asset:${RESET} ${JSON.stringify(asset)}`);
       if (mortality !== undefined)
         console.log(`  ${BOLD}Mortality:${RESET} ${mortality.mortal ? `mortal (period ${mortality.period})` : "immortal"}`);
       if (at !== undefined)
         console.log(`  ${BOLD}At:${RESET}    ${at}`);
-      try {
-        const fees = await tx.getEstimatedFees(signer?.publicKey, txOptions);
-        console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
-      } catch (err) {
+      if (estimatedFees !== undefined) {
+        console.log(`  ${BOLD}Estimated fees:${RESET} ${estimatedFees}`);
+      } else {
         console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
-        console.log(`  ${DIM}${err.message ?? err}${RESET}`);
       }
       return;
     }
     const waitLevel = parseWaitLevel(opts.wait);
+    if (opts.unsigned) {
+      const callDataBytes = await tx.getEncodedData();
+      const userExtOverrides = parseExtOption(opts.ext);
+      const generalTx = buildGeneralTx(meta, callDataBytes, userExtOverrides);
+      if (opts.encode) {
+        const hex = Binary3.toHex(generalTx);
+        if (isJsonOutput(opts)) {
+          console.log(formatJson({ generalTxHex: hex }));
+        } else {
+          console.log(hex);
+        }
+        return;
+      }
+      const observable = clientHandle.client.submitAndWatch(generalTx, at);
+      if (isJsonOutput(opts)) {
+        const result3 = await watchTransactionJson(observable, waitLevel, { unsigned: true });
+        const rpcUrl3 = primaryRpc(opts.rpc ?? chainConfig.rpc);
+        if (result3.type === "broadcasted") {
+          printJsonLine({ event: "broadcasted", txHash: result3.txHash });
+          return;
+        }
+        const blockHash = result3.block.hash;
+        const explorer = {};
+        if (rpcUrl3) {
+          explorer.polkadotjs = pjsAppsLink(rpcUrl3, blockHash);
+          explorer.papi = papiLink(rpcUrl3, blockHash);
+        }
+        printJsonLine({
+          event: result3.type === "finalized" ? "finalized" : "bestBlock",
+          unsigned: true,
+          blockNumber: result3.block.number,
+          blockHash,
+          txHash: result3.txHash,
+          ok: result3.ok,
+          events: result3.events?.map((e) => ({
+            pallet: e.type,
+            name: e.value?.type,
+            fields: e.value?.value
+          })),
+          dispatchError: result3.ok ? null : formatDispatchError(result3.dispatchError),
+          explorer
+        });
+        if (!result3.ok) {
+          throw new CliError(`Transaction dispatch error: ${formatDispatchError(result3.dispatchError)}`);
+        }
+        return;
+      }
+      const result2 = await watchTransaction(observable, waitLevel, { unsigned: true });
+      console.log();
+      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}`);
+      console.log(`  ${BOLD}Tx:${RESET}     ${result2.txHash}`);
+      if (result2.type === "broadcasted") {
+        console.log(`  ${BOLD}Status:${RESET} ${GREEN}broadcasted${RESET}`);
+        console.log(`  ${DIM}Note: tx was broadcast but not yet included in a block${RESET}`);
+        console.log();
+        return;
+      }
+      let dispatchErrorMsg2;
+      if (result2.ok) {
+        const hint = result2.type === "txBestBlocksState" ? ` ${DIM}(best block, not yet finalized)${RESET}` : "";
+        console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}${hint}`);
+      } else {
+        dispatchErrorMsg2 = formatDispatchError(result2.dispatchError);
+        console.log(`  ${BOLD}Status:${RESET} ${RED}dispatch error${RESET}`);
+        console.log(`  ${BOLD}Error:${RESET}  ${dispatchErrorMsg2}`);
+      }
+      if (result2.events && result2.events.length > 0) {
+        console.log(`  ${BOLD}Events:${RESET}`);
+        for (const event of result2.events) {
+          const name = `${CYAN}${event.type}${RESET}.${CYAN}${event.value?.type ?? ""}${RESET}`;
+          const payload = event.value?.value;
+          if (payload && typeof payload === "object") {
+            const fields = Object.entries(payload).map(([k, v]) => `${k}: ${formatEventValue(v)}`).join(", ");
+            console.log(`    ${name} { ${fields} }`);
+          } else {
+            console.log(`    ${name}`);
+          }
+        }
+      }
+      const rpcUrl2 = primaryRpc(opts.rpc ?? chainConfig.rpc);
+      if (rpcUrl2) {
+        const blockHash = result2.block.hash;
+        console.log(`  ${BOLD}Block:${RESET}  #${result2.block.number} (${blockHash})`);
+        console.log(`  ${DIM}${pjsAppsLink(rpcUrl2, blockHash)}${RESET}`);
+        console.log(`  ${DIM}${papiLink(rpcUrl2, blockHash)}${RESET}`);
+      }
+      console.log();
+      if (!result2.ok) {
+        throw new CliError(`Transaction dispatch error: ${dispatchErrorMsg2}`);
+      }
+      return;
+    }
+    if (isJsonOutput(opts)) {
+      const result2 = await watchTransactionJson(tx.signSubmitAndWatch(signer, txOptions), waitLevel);
+      const rpcUrl2 = primaryRpc(opts.rpc ?? chainConfig.rpc);
+      if (result2.type === "broadcasted") {
+        printJsonLine({ event: "broadcasted", txHash: result2.txHash });
+        return;
+      }
+      const blockHash = result2.block.hash;
+      const explorer = {};
+      if (rpcUrl2) {
+        explorer.polkadotjs = pjsAppsLink(rpcUrl2, blockHash);
+        explorer.papi = papiLink(rpcUrl2, blockHash);
+      }
+      printJsonLine({
+        event: result2.type === "finalized" ? "finalized" : "bestBlock",
+        blockNumber: result2.block.number,
+        blockHash,
+        txHash: result2.txHash,
+        ok: result2.ok,
+        events: result2.events?.map((e) => ({
+          pallet: e.type,
+          name: e.value?.type,
+          fields: e.value?.value
+        })),
+        dispatchError: result2.ok ? null : formatDispatchError(result2.dispatchError),
+        explorer
+      });
+      if (!result2.ok) {
+        throw new CliError(`Transaction dispatch error: ${formatDispatchError(result2.dispatchError)}`);
+      }
+      return;
+    }
     const result = await watchTransaction(tx.signSubmitAndWatch(signer, txOptions), waitLevel);
     console.log();
     console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
@@ -4423,6 +5668,8 @@ async function handleTx(target, args, opts) {
       console.log(`  ${BOLD}Nonce:${RESET} ${nonce}`);
     if (tip !== undefined)
       console.log(`  ${BOLD}Tip:${RESET}   ${tip}`);
+    if (asset !== undefined)
+      console.log(`  ${BOLD}Asset:${RESET} ${JSON.stringify(asset)}`);
     if (mortality !== undefined)
       console.log(`  ${BOLD}Mortality:${RESET} ${mortality.mortal ? `mortal (period ${mortality.period})` : "immortal"}`);
     if (at !== undefined)
@@ -4508,7 +5755,7 @@ function decodeCallFallback(meta, callHex) {
   if (callTypeId == null)
     throw new Error("No RuntimeCall type ID");
   const codec = meta.builder.buildDefinition(callTypeId);
-  const decoded = codec.dec(Binary3.fromHex(callHex).asBytes());
+  const decoded = codec.dec(Binary3.fromHex(callHex));
   const palletName2 = decoded.type;
   const call = decoded.value;
   const callName = call.type;
@@ -4524,7 +5771,7 @@ function decodeCallToFileFormat(meta, callHex, chainName) {
   if (callTypeId == null)
     throw new Error("No RuntimeCall type ID in metadata");
   const codec = meta.builder.buildDefinition(callTypeId);
-  const decoded = codec.dec(Binary3.fromHex(callHex).asBytes());
+  const decoded = codec.dec(Binary3.fromHex(callHex));
   const palletName2 = decoded.type;
   const call = decoded.value;
   const callName = call.type;
@@ -4541,8 +5788,8 @@ function decodeCallToFileFormat(meta, callHex, chainName) {
 function sanitizeForSerialization(value) {
   if (value === undefined || value === null)
     return null;
-  if (value instanceof Binary3)
-    return value.asHex();
+  if (value instanceof Uint8Array)
+    return Binary3.toHex(value);
   if (typeof value === "bigint") {
     if (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER) {
       return Number(value);
@@ -4574,8 +5821,8 @@ function outputFileFormat(obj, asYaml) {
 function formatRawDecoded(value) {
   if (value === undefined || value === null)
     return "null";
-  if (value instanceof Binary3)
-    return value.asHex();
+  if (value instanceof Uint8Array)
+    return Binary3.toHex(value);
   if (typeof value === "bigint")
     return value.toString();
   if (typeof value === "string")
@@ -4696,7 +5943,7 @@ function formatEventValue(v) {
     return v.toString();
   if (v === null || v === undefined)
     return "null";
-  if (v instanceof Binary3) {
+  if (v instanceof Uint8Array) {
     return binaryToDisplay(v);
   }
   return JSON.stringify(v, (_k, val) => typeof val === "bigint" ? val.toString() : val);
@@ -4970,7 +6217,7 @@ async function parseTypedArg2(meta, entry, arg) {
     case "enum": {
       if (/^0x[0-9a-fA-F]+$/.test(arg) && meta.lookup.call != null && entry.id === meta.lookup.call) {
         const callCodec = meta.builder.buildDefinition(meta.lookup.call);
-        return callCodec.dec(Binary3.fromHex(arg).asBytes());
+        return callCodec.dec(Binary3.fromHex(arg));
       }
       if (arg.startsWith("{")) {
         try {
@@ -5104,11 +6351,11 @@ function parseExtOption(ext) {
   }
 }
 var NO_DEFAULT2 = Symbol("no-default");
-function buildCustomSignedExtensions(meta, userOverrides) {
+function buildCustomSignedExtensions(meta, userOverrides, builtins = PAPI_BUILTIN_EXTENSIONS2) {
   const result = {};
   const extensions = getSignedExtensions(meta);
   for (const ext of extensions) {
-    if (PAPI_BUILTIN_EXTENSIONS2.has(ext.identifier))
+    if (builtins.has(ext.identifier))
       continue;
     if (ext.identifier in userOverrides) {
       result[ext.identifier] = userOverrides[ext.identifier];
@@ -5140,20 +6387,114 @@ function autoDefaultForType(entry) {
   }
   return NO_DEFAULT2;
 }
-function watchTransaction(observable, level) {
+function unsignedDefaultForType(identifier, entry) {
+  switch (identifier) {
+    case "CheckMortality":
+      return { type: "Immortal" };
+    case "CheckNonce":
+      return 0;
+    case "ChargeTransactionPayment":
+      return 0n;
+    case "ChargeAssetTxPayment":
+      return { tip: 0n, asset_id: undefined };
+  }
+  const auto = autoDefaultForType(entry);
+  if (auto !== NO_DEFAULT2)
+    return auto;
+  if (entry.type === "primitive") {
+    switch (entry.value) {
+      case "bool":
+        return false;
+      case "u8":
+      case "u16":
+      case "u32":
+      case "i8":
+      case "i16":
+      case "i32":
+        return 0;
+      case "u64":
+      case "u128":
+      case "u256":
+      case "i64":
+      case "i128":
+      case "i256":
+        return 0n;
+      case "str":
+      case "char":
+        return "";
+    }
+  }
+  if (entry.type === "compact")
+    return 0;
+  if (entry.type === "enum") {
+    const variants = entry.value;
+    if ("Immortal" in variants)
+      return { type: "Immortal" };
+    for (const [name, variant] of Object.entries(variants)) {
+      if (variant.type === "void")
+        return { type: name };
+    }
+  }
+  return NO_DEFAULT2;
+}
+function buildGeneralTx(meta, callData, userExtOverrides) {
+  const extensions = getSignedExtensions(meta);
+  const extBytes = [];
+  for (const ext of extensions) {
+    const valueEntry = meta.lookup(ext.type);
+    if (valueEntry.type === "void")
+      continue;
+    let value;
+    if (ext.identifier in userExtOverrides) {
+      const override = userExtOverrides[ext.identifier];
+      value = override.value !== undefined ? override.value : override;
+    } else {
+      value = unsignedDefaultForType(ext.identifier, valueEntry);
+      if (value === NO_DEFAULT2) {
+        throw new CliError(`Cannot determine default unsigned value for extension "${ext.identifier}" ` + `(type: ${valueEntry.type}). Provide it via --ext '{"${ext.identifier}":{"value":...}}'`);
+      }
+    }
+    const codec = meta.builder.buildDefinition(ext.type);
+    extBytes.push(codec.enc(value));
+  }
+  const extVersion = new Uint8Array([0]);
+  const versionByte = new Uint8Array([69]);
+  let payloadLen = 1 + 1;
+  for (const b of extBytes)
+    payloadLen += b.length;
+  payloadLen += callData.length;
+  const lengthPrefix = scaleCompact2.enc(payloadLen);
+  const total = new Uint8Array(lengthPrefix.length + payloadLen);
+  let offset = 0;
+  total.set(lengthPrefix, offset);
+  offset += lengthPrefix.length;
+  total.set(versionByte, offset);
+  offset += 1;
+  total.set(extVersion, offset);
+  offset += 1;
+  for (const b of extBytes) {
+    total.set(b, offset);
+    offset += b.length;
+  }
+  total.set(callData, offset);
+  return total;
+}
+function watchTransaction(observable, level, options) {
   const spinner = new Spinner;
   return new Promise((resolve, reject) => {
     let settled = false;
-    spinner.start("Signing...");
+    spinner.start(options?.unsigned ? "Submitting..." : "Signing...");
     const subscription = observable.subscribe({
       next(event) {
         if (settled)
           return;
         switch (event.type) {
           case "signed":
-            spinner.succeed("Signed");
-            console.log(`  ${BOLD}Tx:${RESET}     ${event.txHash}`);
-            spinner.start("Broadcasting...");
+            if (!options?.unsigned) {
+              spinner.succeed("Signed");
+              console.log(`  ${BOLD}Tx:${RESET}     ${event.txHash}`);
+              spinner.start("Broadcasting...");
+            }
             break;
           case "broadcasted":
             if (level === "broadcast") {
@@ -5197,6 +6538,51 @@ function watchTransaction(observable, level) {
     });
   });
 }
+function watchTransactionJson(observable, level, options) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const subscription = observable.subscribe({
+      next(event) {
+        if (settled)
+          return;
+        switch (event.type) {
+          case "signed":
+            if (!options?.unsigned) {
+              printJsonLine({ event: "signed", txHash: event.txHash });
+            }
+            break;
+          case "broadcasted":
+            printJsonLine({ event: "broadcasted", txHash: event.txHash });
+            if (level === "broadcast") {
+              settled = true;
+              subscription.unsubscribe();
+              resolve(event);
+            }
+            break;
+          case "txBestBlocksState":
+            if (event.found) {
+              printJsonLine({ event: "bestBlock", blockNumber: event.block.number, found: true });
+              if (level === "best-block") {
+                settled = true;
+                subscription.unsubscribe();
+                resolve(event);
+              }
+            }
+            break;
+          case "finalized":
+            settled = true;
+            resolve(event);
+            break;
+        }
+      },
+      error(err) {
+        if (settled)
+          return;
+        reject(err);
+      }
+    });
+  });
+}
 
 // src/commands/verifiable.ts
 init_accounts_store();
@@ -5253,7 +6639,7 @@ async function deriveVerifiable(account, opts) {
       await saveAccounts(accountsFile);
     }
   }
-  if (opts.output === "json") {
+  if (isJsonOutput(opts)) {
     const result = {
       account,
       memberKey: memberKeyHex
@@ -5277,8 +6663,14 @@ async function resolveMnemonic(account) {
   const accountsFile = await loadAccounts();
   const stored = findAccount(accountsFile, account);
   if (!stored) {
-    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)];
-    throw new Error(`Unknown account "${account}". Available accounts: ${available.join(", ")}`);
+    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
+    const suggestions = findClosest(account, available);
+    const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+    const list = available.map((a) => `
+    - ${a}`).join("");
+    throw new Error(`Unknown account "${account}".${hint}
+  Available accounts:${list}`);
   }
   if (isWatchOnly(stored)) {
     throw new Error(`Account "${account}" is watch-only (no secret). Cannot derive Bandersnatch key.`);
@@ -5291,8 +6683,9 @@ async function resolveMnemonic(account) {
 }
 
 // src/config/store.ts
+init_errors();
 init_types();
-import { access as access3, mkdir as mkdir3, readFile as readFile5, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { access as access3, mkdir as mkdir3, readFile as readFile7, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { join as join3 } from "node:path";
 var DOT_DIR2 = join3(homedir2(), ".polkadot");
@@ -5312,24 +6705,30 @@ async function fileExists3(path) {
 async function loadConfig2() {
   await ensureDir3(DOT_DIR2);
   if (await fileExists3(CONFIG_PATH2)) {
-    const saved = JSON.parse(await readFile5(CONFIG_PATH2, "utf-8"));
-    return {
-      ...saved,
-      chains: { ...DEFAULT_CONFIG.chains, ...saved.chains }
-    };
+    const saved = JSON.parse(await readFile7(CONFIG_PATH2, "utf-8"));
+    const chains = {};
+    for (const [name, defaultConfig] of Object.entries(DEFAULT_CONFIG.chains)) {
+      chains[name] = saved.chains[name] ? { ...defaultConfig, ...saved.chains[name] } : defaultConfig;
+    }
+    for (const [name, config] of Object.entries(saved.chains)) {
+      if (!(name in DEFAULT_CONFIG.chains)) {
+        chains[name] = config;
+      }
+    }
+    return { chains };
   }
   await saveConfig2(DEFAULT_CONFIG);
   return DEFAULT_CONFIG;
 }
 async function saveConfig2(config) {
   await ensureDir3(DOT_DIR2);
-  await writeFile3(CONFIG_PATH2, `${JSON.stringify(config, null, 2)}
+  await writeFile5(CONFIG_PATH2, `${JSON.stringify(config, null, 2)}
 `);
 }
 
 // src/core/file-loader.ts
 init_errors();
-import { access as access4, readFile as readFile6 } from "node:fs/promises";
+import { access as access4, readFile as readFile8 } from "node:fs/promises";
 import { parse as parseYaml } from "yaml";
 var CATEGORIES = ["tx", "query", "const", "apis"];
 var FILE_EXTENSIONS = [".json", ".yaml", ".yml"];
@@ -5394,7 +6793,7 @@ async function loadCommandFile(filePath, cliVars) {
   } catch {
     throw new CliError(`File not found: ${filePath}`);
   }
-  const rawText = await readFile6(filePath, "utf-8");
+  const rawText = await readFile8(filePath, "utf-8");
   if (!rawText.trim()) {
     throw new CliError(`File is empty: ${filePath}`);
   }
@@ -5427,6 +6826,7 @@ async function loadCommandFile(filePath, cliVars) {
   }
   const doc = parsed;
   const chain = doc.chain != null ? String(doc.chain) : undefined;
+  const unsigned = doc.unsigned === true ? true : undefined;
   const foundCategories = CATEGORIES.filter((c) => (c in doc));
   if (foundCategories.length === 0) {
     throw new CliError(`File "${filePath}" must contain exactly one category key: ${CATEGORIES.join(", ")}. None found.`);
@@ -5457,14 +6857,15 @@ async function loadCommandFile(filePath, cliVars) {
     category,
     pallet,
     item,
-    args: args ?? undefined
+    args: args ?? undefined,
+    unsigned
   };
 }
 
 // src/core/update-notifier.ts
 init_store();
 import { readFileSync } from "node:fs";
-import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile6 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 var CACHE_FILE = "update-check.json";
 var STALE_MS = 24 * 60 * 60 * 1000;
@@ -5534,7 +6935,7 @@ function readCache() {
 async function writeCache(cache) {
   try {
     await mkdir4(getConfigDir(), { recursive: true });
-    await writeFile4(getCachePath(), `${JSON.stringify(cache)}
+    await writeFile6(getCachePath(), `${JSON.stringify(cache)}
 `);
   } catch {}
 }
@@ -5702,13 +7103,15 @@ if (process.argv[2] === "__complete") {
     console.log("  dot query.System.Account <addr>         Query a storage item");
     console.log("  dot query.System                        List storage items in System");
     console.log("  dot tx.System.remark 0xdead --from alice");
+    console.log("  dot tx.System.remark 0xdead --unsigned    Submit unsigned/bare tx");
     console.log("  dot const.Balances.ExistentialDeposit");
     console.log("  dot events.Balances                     List events in Balances");
     console.log("  dot apis.Core.version                    Call a runtime API");
     console.log("  dot polkadot.query.System.Number        With chain prefix");
     console.log("  dot ./transfer.yaml --from alice        Run from file");
-    console.log("  dot tx.0x1f0003... --yaml               Decode hex call to YAML");
-    console.log("  dot tx.System.remark 0xdead --json      Encode & output as JSON file format");
+    console.log("  dot tx.0x1f0003... --to-yaml             Decode hex call to YAML");
+    console.log("  dot tx.System.remark 0xdead --to-json   Encode & output as JSON file format");
+    console.log("  dot query.System.Number --json           Output as JSON");
     console.log();
     console.log("Commands:");
     console.log("  inspect [target]   Inspect chain metadata (alias: explore)");
@@ -5721,21 +7124,21 @@ if (process.argv[2] === "__complete") {
     console.log("  completions <sh>   Generate shell completions (zsh, bash, fish)");
     console.log();
     console.log("Global options:");
-    console.log("  --chain <name>     Target chain (default from config)");
+    console.log("  --chain <name>     Target chain (required)");
     console.log("  --rpc <url>        Override RPC endpoint");
-    console.log("  --light-client     Use Smoldot light client");
+    console.log("  --json             Output as JSON");
     console.log("  --output <format>  Output format: pretty or json");
     console.log("  --help, -h         Display this message");
     console.log("  --version          Show version");
   };
   startBackgroundCheck(version);
   const cli = cac("dot");
-  cli.option("--chain <name>", "Target chain (default from config)");
+  cli.option("--chain <name>", "Target chain (required)");
   cli.option("--rpc <url>", "Override RPC endpoint for this call");
-  cli.option("--light-client", "Use Smoldot light client instead of WebSocket");
   cli.option("--output <format>", "Output format: pretty or json", {
     default: "pretty"
   });
+  cli.option("--json", "Output as JSON (shorthand for --output json)");
   registerChainCommands(cli);
   registerInspectCommand(cli);
   registerAccountCommands(cli);
@@ -5744,9 +7147,9 @@ if (process.argv[2] === "__complete") {
   registerParachainCommand(cli);
   registerCompletionsCommand(cli);
   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("--yaml", "Decode call to YAML file format (for tx)").option("--json", "Decode call to JSON file format (for tx)").option("--ext <json>", "Custom signed extension values as JSON (for tx)").option("-w, --wait <level>", "Resolve at: broadcast, best-block (or best), finalized (for tx)", {
+  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)').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)").action(async (dotpath, args, opts) => {
     if (!dotpath) {
       printHelp();
       return;
@@ -5755,18 +7158,25 @@ if (process.argv[2] === "__complete") {
       const cliVars = collectVarFlags(process.argv);
       const cmd = await loadCommandFile(dotpath, cliVars);
       const effectiveChain2 = opts.chain ?? cmd.chain;
-      const handlerOpts2 = { chain: effectiveChain2, rpc: opts.rpc, output: opts.output };
+      const handlerOpts2 = {
+        chain: effectiveChain2,
+        rpc: opts.rpc,
+        output: opts.output,
+        json: opts.json
+      };
       const target2 = `${cmd.pallet}.${cmd.item}`;
       switch (cmd.category) {
         case "tx":
           await handleTx(target2, args, {
             ...handlerOpts2,
             from: opts.from,
+            unsigned: opts.unsigned ?? cmd.unsigned,
             dryRun: opts.dryRun,
             encode: opts.encode,
-            yaml: opts.yaml,
-            json: opts.json,
+            toYaml: opts.toYaml,
+            toJson: opts.toJson,
             ext: opts.ext,
+            asset: opts.asset,
             wait: opts.wait,
             nonce: opts.nonce,
             tip: opts.tip,
@@ -5812,7 +7222,12 @@ if (process.argv[2] === "__complete") {
       throw new CliError2(`Chain specified both as prefix ("${parsed.chain}") and as --chain flag ("${opts.chain}"). Use one or the other.`);
     }
     const effectiveChain = parsed.chain ?? opts.chain;
-    const handlerOpts = { chain: effectiveChain, rpc: opts.rpc, output: opts.output };
+    const handlerOpts = {
+      chain: effectiveChain,
+      rpc: opts.rpc,
+      output: opts.output,
+      json: opts.json
+    };
     const target = parsed.pallet ? parsed.item ? `${parsed.pallet}.${parsed.item}` : parsed.pallet : undefined;
     if (cli.options.help && parsed.pallet && parsed.item) {
       await showItemHelp2(parsed.category, target, handlerOpts);
@@ -5826,11 +7241,13 @@ if (process.argv[2] === "__complete") {
         const txOpts = {
           ...handlerOpts,
           from: opts.from,
+          unsigned: opts.unsigned,
           dryRun: opts.dryRun,
           encode: opts.encode,
-          yaml: opts.yaml,
-          json: opts.json,
+          toYaml: opts.toYaml,
+          toJson: opts.toJson,
           ext: opts.ext,
+          asset: opts.asset,
           wait: opts.wait,
           nonce: opts.nonce,
           tip: opts.tip,