polkadot-cli 1.13.0 → 1.14.1

package/dist/cli.mjs

@@ -15,6 +15,29 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// 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) {
   return Array.isArray(rpc) ? rpc[0] : rpc;
@@ -22,7 +45,6 @@ function primaryRpc(rpc) {
 var DEFAULT_CONFIG, BUILTIN_CHAIN_NAMES;
 var init_types = __esm(() => {
   DEFAULT_CONFIG = {
-    defaultChain: "polkadot",
     chains: {
       polkadot: {
         rpc: [
@@ -191,7 +213,7 @@ async function loadConfig() {
         chains[name] = config;
       }
     }
-    return { ...saved, chains };
+    return { chains };
   }
   await saveConfig(DEFAULT_CONFIG);
   return DEFAULT_CONFIG;
@@ -223,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");
@@ -602,29 +627,6 @@ 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 { getWsProvider } from "polkadot-api/ws";
@@ -1016,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";
@@ -1259,7 +1262,10 @@ async function parseTypedArg(meta, entry, arg) {
     case "array": {
       const inner = entry.value;
       if (inner.type === "primitive" && inner.value === "u8") {
-        if (/^0x[0-9a-fA-F]*$/.test(arg))
+        const isHex = /^0x[0-9a-fA-F]*$/.test(arg);
+        if (entry.type === "array" && isHex)
+          return arg;
+        if (isHex)
           return Binary2.fromHex(arg);
         return Binary2.fromText(arg);
       }
@@ -1473,12 +1479,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 {
     process.stderr.write(`Fetching metadata from ${chainName}...
 `);
-    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       return await getOrFetchMetadata(chainName, clientHandle);
     } finally {
@@ -2245,7 +2262,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 [];
@@ -2254,7 +2273,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 [];
@@ -2264,7 +2285,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 [];
@@ -2326,7 +2349,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 [];
@@ -2370,7 +2395,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",
@@ -2385,6 +2410,7 @@ var init_complete = __esm(() => {
   GLOBAL_OPTIONS = ["--chain", "--rpc", "--output", "--help", "--version"];
   TX_OPTIONS = [
     "--from",
+    "--unsigned",
     "--dry-run",
     "--encode",
     "--ext",
@@ -2400,12 +2426,13 @@ var init_complete = __esm(() => {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "1.13.0";
+var version = "1.14.1";
 
 // 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)
@@ -2414,6 +2441,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
@@ -2426,6 +2455,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
@@ -2438,7 +2474,7 @@ ${YELLOW}Note: Secrets are stored unencrypted in ~/.polkadot/accounts.json.
       Hex seed import (0x...) is not supported via CLI.${RESET}
 `.trimStart();
 function registerAccountCommands(cli) {
-  cli.command("account [action] [...names]", "Manage local accounts (create, import, list, remove)").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(opts);
@@ -2454,7 +2490,11 @@ function registerAccountCommands(cli) {
           return accountImport(names[0], opts);
         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":
@@ -2916,6 +2956,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();
@@ -3040,29 +3236,35 @@ 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 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 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 default kusama
   $ 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").option("--relay <name>", "Parent relay chain for this parachain").option("--parachain-id <id>", "Parachain ID (auto-detected if omitted with --relay)").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(opts);
@@ -3071,15 +3273,17 @@ function registerChainCommands(cli) {
     }
     switch (action) {
       case "add":
-        return chainAdd(name, opts);
+        return chainAdd(names[0], opts);
       case "remove":
-        return chainRemove(name, opts);
+        return chainRemove(names[0], opts);
       case "list":
         return chainList(opts);
       case "update":
-        return chainUpdate(name, opts);
-      case "default":
-        return chainDefault(name, opts);
+        return chainUpdate(names[0], opts);
+      case "export":
+        return chainExport(names, opts);
+      case "import":
+        return chainImport(names[0], opts);
       default:
         console.error(`Unknown action "${action}".
 `);
@@ -3174,11 +3378,6 @@ async function chainRemove(name, opts = {}) {
     console.error(`Warning: ${orphans.length} chain(s) reference "${resolved}" as their relay: ${orphans.join(", ")}`);
   }
   delete config.chains[resolved];
-  if (config.defaultChain === resolved) {
-    config.defaultChain = "polkadot";
-    if (!isJsonOutput(opts))
-      console.log(`Default chain reset to "polkadot".`);
-  }
   await saveConfig(config);
   await removeChainData(resolved);
   if (isJsonOutput(opts)) {
@@ -3192,7 +3391,6 @@ async function chainList(opts = {}) {
   if (isJsonOutput(opts)) {
     const chains = Object.entries(config.chains).map(([name, chainConfig]) => ({
       name,
-      default: name === config.defaultChain,
       rpc: Array.isArray(chainConfig.rpc) ? chainConfig.rpc : [chainConfig.rpc],
       ...chainConfig.relay && { relay: chainConfig.relay },
       ...chainConfig.parachainId != null && { parachainId: chainConfig.parachainId }
@@ -3221,7 +3419,7 @@ async function chainList(opts = {}) {
   for (const relayName of relayNames) {
     const relayConfig = config.chains[relayName];
     if (relayConfig) {
-      printChainLine("  ", relayName, relayConfig, config.defaultChain);
+      printChainLine("  ", relayName, relayConfig);
     }
     const paras = parachainsByRelay.get(relayName) ?? [];
     for (let i = 0;i < paras.length; i++) {
@@ -3229,21 +3427,19 @@ async function chainList(opts = {}) {
       const isLast = i === paras.length - 1;
       const prefix = isLast ? "  └─ " : "  ├─ ";
       const idSuffix = chainConfig.parachainId != null ? ` ${DIM}[${chainConfig.parachainId}]${RESET}` : "";
-      printChainLine(prefix, name, chainConfig, config.defaultChain, idSuffix);
+      printChainLine(prefix, name, chainConfig, idSuffix);
     }
     console.log();
   }
   for (const [name, chainConfig] of standalone) {
-    printChainLine("  ", name, chainConfig, config.defaultChain);
+    printChainLine("  ", name, chainConfig);
   }
   if (standalone.length > 0)
     console.log();
 }
-function printChainLine(prefix, name, chainConfig, defaultChain, suffix = "") {
-  const isDefault = name === defaultChain;
-  const marker = isDefault ? ` ${BOLD}(default)${RESET}` : "";
+function printChainLine(prefix, name, chainConfig, suffix = "") {
   const rpcs = Array.isArray(chainConfig.rpc) ? chainConfig.rpc : [chainConfig.rpc];
-  console.log(`${prefix}${CYAN}${name}${RESET}${suffix}${marker}  ${DIM}${rpcs[0]}${RESET}`);
+  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}`);
@@ -3255,6 +3451,10 @@ 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);
   process.stderr.write(`Connecting to ${chainName}...
 `);
@@ -3302,23 +3502,132 @@ ${failed} of ${chainNames.length} chains failed to update.`);
     process.exit(1);
   }
 }
-async function chainDefault(name, opts = {}) {
-  if (!name) {
-    console.error("Usage: dot chain default <name>");
-    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 resolved = findChainName(config, name);
-  if (!resolved) {
-    const available = Object.keys(config.chains).join(", ");
-    throw new Error(`Chain "${name}" not found. Available: ${available}`);
+  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;
+      }
+    }
   }
-  config.defaultChain = resolved;
-  await saveConfig(config);
-  if (isJsonOutput(opts)) {
-    console.log(formatJson({ action: "default", chain: resolved }));
+  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 {
-    console.log(`Default chain set to "${resolved}".`);
+    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 {
+      added.push(name);
+      config.chains[name] = chainConfig;
+    }
+  }
+  if (!opts.dryRun) {
+    await saveConfig(config);
+  }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      action: opts.dryRun ? "dry-run" : "imported",
+      added,
+      overwritten,
+      skipped,
+      warnings
+    }));
+    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 chains imported.`);
+  } else if (!opts.dryRun) {
+    console.error(`
+Run "dot chain update --all" to fetch metadata for imported chains.`);
   }
 }
 
@@ -3506,12 +3815,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 {
     process.stderr.write(`Fetching metadata from ${chainName}...
 `);
-    const clientHandle = await createChainClient(chainName, chainConfig, rpcOverride);
+    const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       return await getOrFetchMetadata(chainName, clientHandle);
     } finally {
@@ -4054,7 +4374,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) {
@@ -4064,7 +4384,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) {
@@ -4190,17 +4510,29 @@ function registerInspectCommand(cli) {
     }
     const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
     let meta;
-    try {
-      meta = await getOrFetchMetadata(chainName);
-    } catch {
+    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);
@@ -4754,7 +5086,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());
@@ -4774,7 +5106,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) {
@@ -4854,6 +5186,7 @@ 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";
@@ -4906,6 +5239,20 @@ 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;
@@ -4977,9 +5324,9 @@ async function handleTx(target, args, opts) {
     console.log();
     return;
   }
-  if (!opts.from && !opts.encode && !opts.toYaml && !opts.toJson) {
+  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;
@@ -4999,6 +5346,18 @@ async function handleTx(target, args, opts) {
   if (opts.toYaml && opts.toJson) {
     throw new Error("--to-yaml and --to-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;
   let pallet;
@@ -5010,9 +5369,9 @@ async function handleTx(target, args, opts) {
   }
   const { name: chainName, chain: chainConfig } = resolveChain(config, effectiveChain);
   const decodeOnly = opts.encode || opts.toYaml || opts.toJson;
-  const signer = decodeOnly ? undefined : await resolveAccountSigner(opts.from);
+  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 {
@@ -5031,11 +5390,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;
@@ -5078,7 +5444,7 @@ 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.toYaml || opts.toJson) {
+      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]);
@@ -5100,6 +5466,24 @@ async function handleTx(target, args, opts) {
       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;
@@ -5120,6 +5504,8 @@ async function handleTx(target, args, opts) {
           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)
@@ -5135,6 +5521,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)
@@ -5147,6 +5535,101 @@ async function handleTx(target, args, opts) {
       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);
@@ -5188,6 +5671,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)
@@ -5778,7 +6263,10 @@ async function parseTypedArg2(meta, entry, arg) {
     case "array": {
       const inner = entry.value;
       if (inner.type === "primitive" && inner.value === "u8") {
-        if (/^0x[0-9a-fA-F]*$/.test(arg))
+        const isHex = /^0x[0-9a-fA-F]*$/.test(arg);
+        if (entry.type === "array" && isHex)
+          return arg;
+        if (isHex)
           return Binary3.fromHex(arg);
         return Binary3.fromText(arg);
       }
@@ -5869,11 +6357,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];
@@ -5905,20 +6393,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") {
@@ -5962,7 +6544,7 @@ function watchTransaction(observable, level) {
     });
   });
 }
-function watchTransactionJson(observable, level) {
+function watchTransactionJson(observable, level, options) {
   return new Promise((resolve, reject) => {
     let settled = false;
     const subscription = observable.subscribe({
@@ -5971,7 +6553,9 @@ function watchTransactionJson(observable, level) {
           return;
         switch (event.type) {
           case "signed":
-            printJsonLine({ event: "signed", txHash: event.txHash });
+            if (!options?.unsigned) {
+              printJsonLine({ event: "signed", txHash: event.txHash });
+            }
             break;
           case "broadcasted":
             printJsonLine({ event: "broadcasted", txHash: event.txHash });
@@ -6105,8 +6689,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");
@@ -6126,7 +6711,7 @@ 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"));
+    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;
@@ -6136,20 +6721,20 @@ async function loadConfig2() {
         chains[name] = config;
       }
     }
-    return { ...saved, chains };
+    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"];
@@ -6214,7 +6799,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}`);
   }
@@ -6247,6 +6832,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.`);
@@ -6277,14 +6863,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;
@@ -6354,7 +6941,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 {}
 }
@@ -6522,6 +7109,7 @@ 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");
@@ -6542,7 +7130,7 @@ 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("  --json             Output as JSON");
     console.log("  --output <format>  Output format: pretty or json");
@@ -6551,7 +7139,7 @@ if (process.argv[2] === "__complete") {
   };
   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("--output <format>", "Output format: pretty or json", {
     default: "pretty"
@@ -6565,9 +7153,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("--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("-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;
@@ -6588,11 +7176,13 @@ if (process.argv[2] === "__complete") {
           await handleTx(target2, args, {
             ...handlerOpts2,
             from: opts.from,
+            unsigned: opts.unsigned ?? cmd.unsigned,
             dryRun: opts.dryRun,
             encode: opts.encode,
             toYaml: opts.toYaml,
             toJson: opts.toJson,
             ext: opts.ext,
+            asset: opts.asset,
             wait: opts.wait,
             nonce: opts.nonce,
             tip: opts.tip,
@@ -6657,11 +7247,13 @@ if (process.argv[2] === "__complete") {
         const txOpts = {
           ...handlerOpts,
           from: opts.from,
+          unsigned: opts.unsigned,
           dryRun: opts.dryRun,
           encode: opts.encode,
           toYaml: opts.toYaml,
           toJson: opts.toJson,
           ext: opts.ext,
+          asset: opts.asset,
           wait: opts.wait,
           nonce: opts.nonce,
           tip: opts.tip,