polkadot-cli 0.6.0 → 0.6.2

package/dist/cli.mjs

@@ -4,11 +4,17 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
 import cac from "cac";
+// package.json
+var version = "0.6.2";
+
+// src/config/accounts-store.ts
+import { access as access2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
 
 // src/config/store.ts
-import { join } from "node:path";
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { mkdir, readFile, writeFile, rm, access } from "node:fs/promises";
+import { join } from "node:path";
 
 // src/config/types.ts
 var DEFAULT_CONFIG = {
@@ -55,7 +61,7 @@ async function loadConfig() {
 }
 async function saveConfig(config) {
   await ensureDir(DOT_DIR);
-  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
 `);
 }
 async function loadMetadata(chainName) {
@@ -84,238 +90,125 @@ function resolveChain(config, chainFlag) {
   return { name, chain };
 }
 
-// src/core/client.ts
-import { createClient } from "polkadot-api";
-import { getWsProvider } from "polkadot-api/ws-provider";
-import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
-
-// src/utils/errors.ts
-class CliError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CliError";
-  }
+// src/config/accounts-store.ts
+var ACCOUNTS_PATH = join2(getConfigDir(), "accounts.json");
+async function ensureDir2(dir) {
+  await mkdir2(dir, { recursive: true });
 }
-
-class ConnectionError extends CliError {
-  constructor(message) {
-    super(message);
-    this.name = "ConnectionError";
+async function fileExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
   }
 }
-
-class MetadataError extends CliError {
-  constructor(message) {
-    super(message);
-    this.name = "MetadataError";
+async function loadAccounts() {
+  await ensureDir2(getConfigDir());
+  if (await fileExists2(ACCOUNTS_PATH)) {
+    const data = await readFile2(ACCOUNTS_PATH, "utf-8");
+    return JSON.parse(data);
   }
+  return { accounts: [] };
 }
-
-// src/core/client.ts
-var KNOWN_CHAIN_SPECS = {
-  polkadot: "polkadot-api/chains/polkadot",
-  kusama: "polkadot-api/chains/ksmcc3",
-  westend: "polkadot-api/chains/westend2",
-  paseo: "polkadot-api/chains/paseo"
-};
-function suppressWsNoise() {
-  const orig = console.error;
-  console.error = (...args) => {
-    if (typeof args[0] === "string" && args[0].includes("Unable to connect"))
-      return;
-    orig(...args);
-  };
-  return () => {
-    console.error = orig;
-  };
-}
-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 }));
-  }
-  const client = createClient(provider, {
-    getMetadata: async () => loadMetadata(chainName),
-    setMetadata: async (_codeHash, metadata) => {
-      await saveMetadata(chainName, metadata);
-    }
-  });
-  return {
-    client,
-    destroy: () => {
-      client.destroy();
-      restoreConsole();
-    }
-  };
+async function saveAccounts(file) {
+  await ensureDir2(getConfigDir());
+  await writeFile2(ACCOUNTS_PATH, `${JSON.stringify(file, null, 2)}
+`);
 }
-async function createSmoldotProvider(chainName) {
-  const { start } = await import("polkadot-api/smoldot");
-  const { getSmProvider } = await import("polkadot-api/sm-provider");
-  const specPath = KNOWN_CHAIN_SPECS[chainName];
-  if (!specPath) {
-    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(specPath);
-  const smoldot = start();
-  const chain = await smoldot.addChain({ chainSpec });
-  return getSmProvider(chain);
+function findAccount(file, name) {
+  return file.accounts.find((a) => a.name.toLowerCase() === name.toLowerCase());
 }
 
-// src/core/metadata.ts
+// src/core/accounts.ts
+import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import {
-  decAnyMetadata,
-  unifyMetadata
-} from "@polkadot-api/substrate-bindings";
-import { getLookupFn, getDynamicBuilder } from "@polkadot-api/metadata-builders";
-var METADATA_TIMEOUT_MS = 15000;
-function parseMetadata(raw) {
-  const decoded = decAnyMetadata(raw);
-  const unified = unifyMetadata(decoded);
-  const lookup = getLookupFn(unified);
-  const builder = getDynamicBuilder(lookup);
-  return { unified, lookup, builder };
-}
-async function fetchMetadataFromChain(clientHandle, chainName) {
-  const { client } = clientHandle;
-  try {
-    const hex = await Promise.race([
-      client._request("state_getMetadata", []),
-      new Promise((_, reject) => setTimeout(() => reject(new ConnectionError(`Timed out fetching metadata for "${chainName}" after ${METADATA_TIMEOUT_MS / 1000}s. ` + "Check that the RPC endpoint is correct and reachable.")), METADATA_TIMEOUT_MS))
-    ]);
-    const bytes = hexToBytes(hex);
-    await saveMetadata(chainName, bytes);
-    return bytes;
-  } catch (err) {
-    if (err instanceof ConnectionError)
-      throw err;
-    throw new ConnectionError(`Failed to fetch metadata for "${chainName}": ${err instanceof Error ? err.message : err}. ` + "Check that the RPC endpoint is correct and reachable.");
-  }
+  DEV_PHRASE,
+  entropyToMiniSecret,
+  generateMnemonic,
+  mnemonicToEntropy,
+  ss58Address,
+  validateMnemonic
+} from "@polkadot-labs/hdkd-helpers";
+import { getPolkadotSigner } from "polkadot-api/signer";
+var DEV_NAMES = ["alice", "bob", "charlie", "dave", "eve", "ferdie"];
+function isDevAccount(name) {
+  return DEV_NAMES.includes(name.toLowerCase());
 }
-async function getOrFetchMetadata(chainName, clientHandle) {
-  let raw = await loadMetadata(chainName);
-  if (!raw) {
-    if (!clientHandle) {
-      throw new MetadataError(`No cached metadata for chain "${chainName}". Run a command that connects to the chain first, ` + `e.g.: dot chain add ${chainName} --rpc <url>`);
-    }
-    raw = await fetchMetadataFromChain(clientHandle, chainName);
-  }
-  return parseMetadata(raw);
+function devDerivationPath(name) {
+  return `//${name.charAt(0).toUpperCase()}${name.slice(1).toLowerCase()}`;
 }
-function listPallets(meta) {
-  return meta.unified.pallets.map((p) => ({
-    name: p.name,
-    index: p.index,
-    docs: p.docs ?? [],
-    storage: (p.storage?.items ?? []).map((s) => ({
-      name: s.name,
-      docs: s.docs ?? [],
-      type: s.type.tag,
-      keyTypeId: s.type.tag === "map" ? s.type.value.key : null,
-      valueTypeId: s.type.tag === "plain" ? s.type.value : s.type.value.value
-    })),
-    constants: (p.constants ?? []).map((c) => ({
-      name: c.name,
-      docs: c.docs ?? [],
-      typeId: c.type
-    })),
-    calls: extractCalls(meta, p.calls)
-  }));
+function deriveFromMnemonic(mnemonic, path) {
+  const entropy = mnemonicToEntropy(mnemonic);
+  const miniSecret = entropyToMiniSecret(entropy);
+  const derive = sr25519CreateDerive(miniSecret);
+  return derive(path);
 }
-function extractCalls(meta, callsRef) {
-  if (!callsRef)
-    return [];
-  try {
-    const entry = meta.lookup(callsRef.type);
-    if (entry.type !== "enum")
-      return [];
-    return Object.entries(entry.value).map(([name, variant]) => ({
-      name,
-      docs: variant.docs ?? [],
-      typeId: resolveCallTypeId(variant)
-    }));
-  } catch {
-    return [];
+function deriveFromHexSeed(hexSeed, path) {
+  const clean = hexSeed.startsWith("0x") ? hexSeed.slice(2) : hexSeed;
+  const seed = new Uint8Array(clean.length / 2);
+  for (let i = 0;i < clean.length; i += 2) {
+    seed[i / 2] = parseInt(clean.substring(i, i + 2), 16);
   }
+  const derive = sr25519CreateDerive(seed);
+  return derive(path);
 }
-function resolveCallTypeId(variant) {
-  if (variant.type === "lookupEntry")
-    return variant.value?.id ?? null;
-  if (variant.type === "struct")
-    return null;
-  if (variant.type === "void" || variant.type === "empty")
-    return null;
-  return null;
+function getDevKeypair(name) {
+  const path = devDerivationPath(name);
+  return deriveFromMnemonic(DEV_PHRASE, path);
 }
-function findPallet(meta, palletName) {
-  const pallets = listPallets(meta);
-  return pallets.find((p) => p.name.toLowerCase() === palletName.toLowerCase());
+function getDevAddress(name, prefix = 42) {
+  const keypair = getDevKeypair(name);
+  return ss58Address(keypair.publicKey, prefix);
 }
-function getSignedExtensions(meta) {
-  const byVersion = meta.unified.extrinsic.signedExtensions;
-  const versionKeys = Object.keys(byVersion);
-  if (versionKeys.length === 0)
-    return [];
-  return byVersion[Number(versionKeys[0])] ?? [];
+function createNewAccount() {
+  const mnemonic = generateMnemonic();
+  const entropy = mnemonicToEntropy(mnemonic);
+  const miniSecret = entropyToMiniSecret(entropy);
+  const derive = sr25519CreateDerive(miniSecret);
+  const keypair = derive("");
+  return { mnemonic, publicKey: keypair.publicKey };
 }
-function getPalletNames(meta) {
-  return meta.unified.pallets.map((p) => p.name);
+function importAccount(secret) {
+  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(secret);
+  if (isHexSeed) {
+    const keypair2 = deriveFromHexSeed(secret, "");
+    return { publicKey: keypair2.publicKey };
+  }
+  if (!validateMnemonic(secret)) {
+    throw new Error("Invalid secret. Expected a 0x-prefixed 32-byte hex seed or a valid BIP39 mnemonic.");
+  }
+  const keypair = deriveFromMnemonic(secret, "");
+  return { publicKey: keypair.publicKey };
 }
-function describeType(lookup, typeId) {
-  try {
-    const entry = lookup(typeId);
-    return formatLookupEntry(entry);
-  } catch {
-    return `type(${typeId})`;
+function publicKeyToHex(publicKey) {
+  return "0x" + Array.from(publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toSs58(publicKey, prefix = 42) {
+  if (typeof publicKey === "string") {
+    const clean = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0;i < clean.length; i += 2) {
+      bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+    }
+    return ss58Address(bytes, prefix);
   }
+  return ss58Address(publicKey, prefix);
 }
-function formatLookupEntry(entry) {
-  switch (entry.type) {
-    case "primitive":
-      return entry.value;
-    case "compact":
-      return `Compact<${formatLookupEntry(entry.isBig ? { type: "primitive", value: "u128" } : { type: "primitive", value: "u64" })}>`;
-    case "AccountId32":
-      return "AccountId32";
-    case "bitSequence":
-      return "BitSequence";
-    case "sequence":
-      return `Vec<${formatLookupEntry(entry.value)}>`;
-    case "array":
-      return `[${formatLookupEntry(entry.value)}; ${entry.len}]`;
-    case "tuple":
-      return `(${entry.value.map(formatLookupEntry).join(", ")})`;
-    case "struct":
-      return `{ ${Object.entries(entry.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ")} }`;
-    case "option":
-      return `Option<${formatLookupEntry(entry.value)}>`;
-    case "result":
-      return `Result<${formatLookupEntry(entry.value.ok)}, ${formatLookupEntry(entry.value.ko)}>`;
-    case "enum": {
-      const variants = Object.keys(entry.value);
-      if (variants.length <= 4)
-        return variants.join(" | ");
-      return `enum(${variants.length} variants)`;
-    }
-    default:
-      return "unknown";
+async function resolveAccountSigner(name) {
+  if (isDevAccount(name)) {
+    const keypair2 = getDevKeypair(name);
+    return getPolkadotSigner(keypair2.publicKey, "Sr25519", keypair2.sign);
   }
-}
-function hexToBytes(hex) {
-  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0;i < clean.length; i += 2) {
-    bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+  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(", ")}`);
   }
-  return bytes;
+  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(account.secret);
+  const keypair = isHexSeed ? deriveFromHexSeed(account.secret, account.derivationPath) : deriveFromMnemonic(account.secret, account.derivationPath);
+  return getPolkadotSigner(keypair.publicKey, "Sr25519", keypair.sign);
 }
 
 // src/core/output.ts
@@ -323,6 +216,7 @@ var isTTY = process.stdout.isTTY ?? false;
 var RESET = isTTY ? "\x1B[0m" : "";
 var CYAN = isTTY ? "\x1B[36m" : "";
 var GREEN = isTTY ? "\x1B[32m" : "";
+var RED = isTTY ? "\x1B[31m" : "";
 var YELLOW = isTTY ? "\x1B[33m" : "";
 var MAGENTA = isTTY ? "\x1B[35m" : "";
 var DIM = isTTY ? "\x1B[2m" : "";
@@ -331,7 +225,7 @@ function replacer(_key, value) {
   if (typeof value === "bigint")
     return value.toString();
   if (value instanceof Uint8Array)
-    return "0x" + Buffer.from(value).toString("hex");
+    return `0x${Buffer.from(value).toString("hex")}`;
   return value;
 }
 function formatJson(data) {
@@ -405,686 +299,917 @@ class Spinner {
   }
 }
 
-// src/commands/chain.ts
-var CHAIN_HELP = `
+// src/commands/account.ts
+var ACCOUNT_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 list                      List configured chains
-  $ dot chain default <name>            Set the default chain
+  $ dot account create <name>                Create a new account
+  $ dot account import <name> --secret <s>   Import from BIP39 mnemonic
+  $ dot account list                         List all accounts
+  $ dot account remove <name>                Remove a stored account
 
 ${BOLD}Examples:${RESET}
-  $ dot chain add kusama --rpc wss://kusama-rpc.polkadot.io
-  $ dot chain add westend --light-client
-  $ dot chain default kusama
-  $ dot chain list
-  $ dot chain update
-  $ dot chain update kusama
-  $ dot chain remove kusama
+  $ dot account create my-validator
+  $ dot account import treasury --secret "word1 word2 ... word12"
+  $ dot account list
+  $ dot account remove my-validator
+
+${YELLOW}Note: Secrets are stored unencrypted in ~/.polkadot/accounts.json.
+      Hex seed import (0x...) is not supported via CLI.${RESET}
 `.trimStart();
-function registerChainCommands(cli) {
-  cli.command("chain [action] [name]", "Manage chains (add, remove, update, list, default)").action(async (action, name, opts) => {
+function registerAccountCommands(cli) {
+  cli.command("account [action] [name]", "Manage local accounts (create, import, list, remove)").option("--secret <value>", "Secret key (mnemonic or hex seed) for import").action(async (action, name, opts) => {
     if (!action) {
-      console.log(CHAIN_HELP);
+      console.log(ACCOUNT_HELP);
       return;
     }
     switch (action) {
-      case "add":
-        return chainAdd(name, opts);
-      case "remove":
-        return chainRemove(name);
+      case "create":
+        return accountCreate(name);
+      case "import":
+        return accountImport(name, opts);
       case "list":
-        return chainList();
-      case "update":
-        return chainUpdate(name, opts);
-      case "default":
-        return chainDefault(name);
+        return accountList();
+      case "remove":
+        return accountRemove(name);
       default:
         console.error(`Unknown action "${action}".
 `);
-        console.log(CHAIN_HELP);
+        console.log(ACCOUNT_HELP);
         process.exit(1);
     }
   });
 }
-async function chainAdd(name, opts) {
+async function accountCreate(name) {
   if (!name) {
-    console.error(`Chain name is required.
+    console.error(`Account name is required.
 `);
-    console.error("Usage: dot chain add <name> --rpc <url>");
-    console.error("       dot chain add <name> --light-client");
+    console.error("Usage: dot account create <name>");
     process.exit(1);
   }
-  if (!opts.rpc && !opts.lightClient) {
-    console.error(`Must provide either --rpc <url> or --light-client.
-`);
-    console.error("Usage: dot chain add <name> --rpc <url>");
-    console.error("       dot chain add <name> --light-client");
-    process.exit(1);
+  if (isDevAccount(name)) {
+    throw new Error(`"${name}" is a built-in dev account and cannot be used as a custom account name.`);
   }
-  const chainConfig = {
-    rpc: opts.rpc ?? "",
-    ...opts.lightClient ? { lightClient: true } : {}
-  };
-  console.log(`Connecting to ${name}...`);
-  const clientHandle = await createChainClient(name, chainConfig, opts.rpc);
-  try {
-    console.log("Fetching metadata...");
-    await fetchMetadataFromChain(clientHandle, name);
-    const config = await loadConfig();
-    config.chains[name] = chainConfig;
-    await saveConfig(config);
-    console.log(`Chain "${name}" added successfully.`);
-  } finally {
-    clientHandle.destroy();
+  const accountsFile = await loadAccounts();
+  if (findAccount(accountsFile, name)) {
+    throw new Error(`Account "${name}" already exists.`);
   }
+  const { mnemonic, publicKey } = createNewAccount();
+  const hexPub = publicKeyToHex(publicKey);
+  const address = toSs58(publicKey);
+  accountsFile.accounts.push({
+    name,
+    secret: mnemonic,
+    publicKey: hexPub,
+    derivationPath: ""
+  });
+  await saveAccounts(accountsFile);
+  printHeading("Account Created");
+  console.log(`  ${BOLD}Name:${RESET}     ${name}`);
+  console.log(`  ${BOLD}Address:${RESET}  ${address}`);
+  console.log(`  ${BOLD}Mnemonic:${RESET} ${mnemonic}`);
+  console.log();
+  console.log(`  ${YELLOW}Save this mnemonic phrase! It is the only way to recover this account.${RESET}`);
+  console.log();
 }
-async function chainRemove(name) {
+async function accountImport(name, opts) {
   if (!name) {
-    console.error("Usage: dot chain remove <name>");
+    console.error(`Account name is required.
+`);
+    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
     process.exit(1);
   }
-  const config = await loadConfig();
-  if (!config.chains[name]) {
-    throw new Error(`Chain "${name}" not found.`);
-  }
-  if (name === "polkadot") {
-    throw new Error('Cannot remove the built-in "polkadot" chain.');
+  if (!opts.secret) {
+    console.error(`--secret is required.
+`);
+    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
+    process.exit(1);
   }
-  delete config.chains[name];
-  if (config.defaultChain === name) {
-    config.defaultChain = "polkadot";
-    console.log(`Default chain reset to "polkadot".`);
+  if (isDevAccount(name)) {
+    throw new Error(`"${name}" is a built-in dev account and cannot be used as a custom account name.`);
   }
-  await saveConfig(config);
-  await removeChainData(name);
-  console.log(`Chain "${name}" removed.`);
-}
-async function chainList() {
-  const config = await loadConfig();
-  printHeading("Configured Chains");
-  for (const [name, chainConfig] of Object.entries(config.chains)) {
-    const isDefault = name === config.defaultChain;
-    const marker = isDefault ? ` ${BOLD}(default)${RESET}` : "";
-    const provider = chainConfig.lightClient ? `${DIM}light-client${RESET}` : `${DIM}${chainConfig.rpc}${RESET}`;
-    console.log(`  ${CYAN}${name}${RESET}${marker}  ${provider}`);
+  const accountsFile = await loadAccounts();
+  if (findAccount(accountsFile, name)) {
+    throw new Error(`Account "${name}" already exists.`);
   }
+  const { publicKey } = importAccount(opts.secret);
+  const hexPub = publicKeyToHex(publicKey);
+  const address = toSs58(publicKey);
+  accountsFile.accounts.push({
+    name,
+    secret: opts.secret,
+    publicKey: hexPub,
+    derivationPath: ""
+  });
+  await saveAccounts(accountsFile);
+  printHeading("Account Imported");
+  console.log(`  ${BOLD}Name:${RESET}    ${name}`);
+  console.log(`  ${BOLD}Address:${RESET} ${address}`);
   console.log();
 }
-async function chainUpdate(name, opts) {
-  const config = await loadConfig();
-  const { name: chainName, chain: chainConfig } = resolveChain(config, name);
-  console.log(`Connecting to ${chainName}...`);
-  const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-  try {
-    console.log("Fetching metadata...");
-    await fetchMetadataFromChain(clientHandle, chainName);
-    console.log(`Metadata for "${chainName}" updated.`);
-  } finally {
-    clientHandle.destroy();
+async function accountList() {
+  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) {
+      const address = toSs58(account.publicKey);
+      printItem(account.name, address);
+    }
+  } else {
+    printHeading("Stored Accounts");
+    console.log("  (none)");
   }
+  console.log();
 }
-async function chainDefault(name) {
+async function accountRemove(name) {
   if (!name) {
-    console.error("Usage: dot chain default <name>");
+    console.error(`Account name is required.
+`);
+    console.error("Usage: dot account remove <name>");
     process.exit(1);
   }
-  const config = await loadConfig();
-  if (!config.chains[name]) {
-    const available = Object.keys(config.chains).join(", ");
-    throw new Error(`Chain "${name}" not found. Available: ${available}`);
+  if (isDevAccount(name)) {
+    throw new Error("Cannot remove built-in dev accounts.");
   }
-  config.defaultChain = name;
-  await saveConfig(config);
-  console.log(`Default chain set to "${name}".`);
-}
-
-// src/utils/parse-target.ts
-function parseTarget(input) {
-  const parts = input.split(".");
-  if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+  const accountsFile = await loadAccounts();
+  const idx = accountsFile.accounts.findIndex((a) => a.name.toLowerCase() === name.toLowerCase());
+  if (idx === -1) {
+    throw new Error(`Account "${name}" not found.`);
   }
-  return { pallet: parts[0], item: parts[1] };
+  accountsFile.accounts.splice(idx, 1);
+  await saveAccounts(accountsFile);
+  console.log(`Account "${name}" removed.`);
 }
 
-// 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);
-    }
+// src/core/client.ts
+import { createClient } from "polkadot-api";
+import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
+import { getWsProvider } from "polkadot-api/ws-provider";
+
+// src/utils/errors.ts
+class CliError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliError";
   }
-  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}".`;
+
+class ConnectionError extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
   }
-  if (suggestions.length === 1 && suggestions[0].toLowerCase() === input.toLowerCase()) {
-    return suggestions[0];
+}
+
+class MetadataError extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "MetadataError";
   }
-  return `Unknown ${kind} "${input}". Did you mean: ${suggestions.join(", ")}?`;
 }
 
-// src/commands/inspect.ts
-function registerInspectCommand(cli) {
-  cli.command("inspect [target]", "Inspect chain metadata (pallets, storage, constants)").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
-    const config = await loadConfig();
-    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
-    let meta;
-    try {
-      meta = await getOrFetchMetadata(chainName);
-    } catch {
-      console.log(`Fetching metadata from ${chainName}...`);
-      const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-      try {
-        meta = await getOrFetchMetadata(chainName, clientHandle);
-      } finally {
-        clientHandle.destroy();
-      }
-    }
-    if (!target) {
-      const pallets = listPallets(meta);
-      printHeading(`Pallets on ${chainName} (${pallets.length})`);
-      for (const p of pallets) {
-        const counts = [];
-        if (p.storage.length)
-          counts.push(`${p.storage.length} storage`);
-        if (p.constants.length)
-          counts.push(`${p.constants.length} constants`);
-        printItem(p.name, counts.join(", "));
-      }
-      console.log();
-      return;
-    }
-    if (!target.includes(".")) {
-      const palletNames2 = getPalletNames(meta);
-      const pallet2 = findPallet(meta, target);
-      if (!pallet2) {
-        throw new Error(suggestMessage("pallet", target, palletNames2));
-      }
-      printHeading(`${pallet2.name} Pallet`);
-      if (pallet2.docs.length) {
-        printDocs(pallet2.docs);
-        console.log();
-      }
-      if (pallet2.storage.length) {
-        console.log(`  ${BOLD}Storage Items:${RESET}`);
-        for (const s of pallet2.storage) {
-          const doc = s.docs[0] ? ` — ${s.docs[0].slice(0, 80)}` : "";
-          console.log(`    ${CYAN}${s.name}${RESET}${DIM}${doc}${RESET}`);
-        }
-        console.log();
-      }
-      if (pallet2.constants.length) {
-        console.log(`  ${BOLD}Constants:${RESET}`);
-        for (const c of pallet2.constants) {
-          const doc = c.docs[0] ? ` — ${c.docs[0].slice(0, 80)}` : "";
-          console.log(`    ${CYAN}${c.name}${RESET}${DIM}${doc}${RESET}`);
-        }
-        console.log();
-      }
-      return;
-    }
-    const { pallet: palletName, item: itemName } = parseTarget(target);
-    const palletNames = getPalletNames(meta);
-    const pallet = findPallet(meta, palletName);
-    if (!pallet) {
-      throw new Error(suggestMessage("pallet", palletName, palletNames));
-    }
-    const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
-    if (storageItem) {
-      printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
-      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
-      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
-      if (storageItem.keyTypeId != null) {
-        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
-      }
-      if (storageItem.docs.length) {
-        console.log();
-        printDocs(storageItem.docs);
-      }
-      console.log();
+// src/core/client.ts
+var KNOWN_CHAIN_SPECS = {
+  polkadot: "polkadot-api/chains/polkadot",
+  kusama: "polkadot-api/chains/ksmcc3",
+  westend: "polkadot-api/chains/westend2",
+  paseo: "polkadot-api/chains/paseo"
+};
+function suppressWsNoise() {
+  const orig = console.error;
+  console.error = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("Unable to connect"))
       return;
+    orig(...args);
+  };
+  return () => {
+    console.error = orig;
+  };
+}
+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>`);
     }
-    const constantItem = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
-    if (constantItem) {
-      printHeading(`${pallet.name}.${constantItem.name} (Constant)`);
-      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constantItem.typeId)}`);
-      if (constantItem.docs.length) {
-        console.log();
-        printDocs(constantItem.docs);
-      }
-      console.log();
-      return;
+    provider = withPolkadotSdkCompat(getWsProvider(rpc, { timeout: 1e4 }));
+  }
+  const client = createClient(provider, {
+    getMetadata: async () => loadMetadata(chainName),
+    setMetadata: async (_codeHash, metadata) => {
+      await saveMetadata(chainName, metadata);
     }
-    const allItems = [
-      ...pallet.storage.map((s) => s.name),
-      ...pallet.constants.map((c) => c.name)
-    ];
-    throw new Error(suggestMessage(`item in ${pallet.name}`, itemName, allItems));
   });
+  return {
+    client,
+    destroy: () => {
+      client.destroy();
+      restoreConsole();
+    }
+  };
 }
-
-// src/utils/parse-value.ts
-function parseValue(arg) {
-  if (/^\d+$/.test(arg))
-    return parseInt(arg, 10);
-  if (/^\d{16,}$/.test(arg))
-    return BigInt(arg);
-  if (/^0x[0-9a-fA-F]+$/.test(arg))
-    return arg;
-  if (arg === "true")
-    return true;
-  if (arg === "false")
-    return false;
-  if (arg.startsWith("{") || arg.startsWith("[")) {
-    try {
-      return JSON.parse(arg);
-    } catch {}
+async function createSmoldotProvider(chainName) {
+  const { start } = await import("polkadot-api/smoldot");
+  const { getSmProvider } = await import("polkadot-api/sm-provider");
+  const specPath = KNOWN_CHAIN_SPECS[chainName];
+  if (!specPath) {
+    throw new ConnectionError(`Light client is only supported for known chains: ${Object.keys(KNOWN_CHAIN_SPECS).join(", ")}. Use --rpc to connect to "${chainName}" instead.`);
   }
-  return arg;
+  const { chainSpec } = await import(specPath);
+  const smoldot = start();
+  const chain = await smoldot.addChain({ chainSpec });
+  return getSmProvider(chain);
 }
 
-// src/commands/query.ts
-var DEFAULT_LIMIT = 100;
-function registerQueryCommand(cli) {
-  cli.command("query [target] [...keys]", "Query on-chain storage (e.g. System.Number, System.Account <addr>)").option("--limit <n>", "Max entries to return for map queries (0 = unlimited)", {
-    default: DEFAULT_LIMIT
-  }).action(async (target, keys, opts) => {
-    if (!target) {
-      console.log("Usage: dot query <Pallet.Item> [...keys] [--chain <name>] [--output json]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot query System.Number                         # plain storage value");
-      console.log("  $ dot query System.Account 5Grw...                # single map entry");
-      console.log("  $ dot query System.Account                        # all entries (limit 100)");
-      console.log("  $ dot query System.Account --limit 10             # first 10 entries");
-      console.log("  $ dot query System.Account --limit 0              # all entries (no limit)");
-      console.log("  $ dot query Assets.Metadata 42 --chain asset-hub");
-      return;
-    }
-    const config = await loadConfig();
-    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
-    const { pallet, item } = parseTarget(target);
-    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-    try {
-      const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
-      }
-      const storageItem = palletInfo.storage.find((s) => s.name.toLowerCase() === item.toLowerCase());
-      if (!storageItem) {
-        const storageNames = palletInfo.storage.map((s) => s.name);
-        throw new Error(suggestMessage(`storage item in ${palletInfo.name}`, item, storageNames));
-      }
-      const unsafeApi = clientHandle.client.getUnsafeApi();
-      const storageApi = unsafeApi.query[palletInfo.name][storageItem.name];
-      const parsedKeys = keys.map(parseValue);
-      const format = opts.output ?? "pretty";
-      if (storageItem.type === "map" && parsedKeys.length === 0) {
-        const entries = await storageApi.getEntries();
-        const limit = Number(opts.limit);
-        const truncated = limit > 0 && entries.length > limit;
-        const display = truncated ? entries.slice(0, limit) : entries;
-        printResult(display.map((e) => ({
-          keys: e.keyArgs,
-          value: e.value
-        })), format);
-        if (truncated) {
-          console.error(`
-${DIM}Showing ${limit} of ${entries.length} entries. Use --limit 0 for all.${RESET}`);
-        }
-      } else {
-        const result = await storageApi.getValue(...parsedKeys);
-        printResult(result, format);
-      }
-    } finally {
-      clientHandle.destroy();
-    }
-  });
-}
-
-// src/commands/const.ts
-function registerConstCommand(cli) {
-  cli.command("const [target]", "Look up a pallet constant (e.g. Balances.ExistentialDeposit)").action(async (target, opts) => {
-    if (!target) {
-      console.log("Usage: dot const <Pallet.Constant> [--chain <name>] [--output json]");
-      console.log("");
-      console.log("Examples:");
-      console.log("  $ dot const Balances.ExistentialDeposit");
-      console.log("  $ dot const System.SS58Prefix --chain kusama");
-      return;
-    }
-    const config = await loadConfig();
-    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
-    const { pallet, item } = parseTarget(target);
-    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
-    try {
-      const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
-      }
-      const constantItem = palletInfo.constants.find((c) => c.name.toLowerCase() === item.toLowerCase());
-      if (!constantItem) {
-        const constNames = palletInfo.constants.map((c) => c.name);
-        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);
-      printResult(result, opts.output ?? "pretty");
-    } finally {
-      clientHandle.destroy();
-    }
-  });
-}
-
-// src/config/accounts-store.ts
-import { join as join2 } from "node:path";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, access as access2 } from "node:fs/promises";
-var ACCOUNTS_PATH = join2(getConfigDir(), "accounts.json");
-async function ensureDir2(dir) {
-  await mkdir2(dir, { recursive: true });
+// src/core/metadata.ts
+import { getDynamicBuilder, getLookupFn } from "@polkadot-api/metadata-builders";
+import { decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
+var METADATA_TIMEOUT_MS = 15000;
+function parseMetadata(raw) {
+  const decoded = decAnyMetadata(raw);
+  const unified = unifyMetadata(decoded);
+  const lookup = getLookupFn(unified);
+  const builder = getDynamicBuilder(lookup);
+  return { unified, lookup, builder };
 }
-async function fileExists2(path) {
+async function fetchMetadataFromChain(clientHandle, chainName) {
+  const { client } = clientHandle;
   try {
-    await access2(path);
-    return true;
-  } catch {
-    return false;
+    const hex = await Promise.race([
+      client._request("state_getMetadata", []),
+      new Promise((_, reject) => setTimeout(() => reject(new ConnectionError(`Timed out fetching metadata for "${chainName}" after ${METADATA_TIMEOUT_MS / 1000}s. ` + "Check that the RPC endpoint is correct and reachable.")), METADATA_TIMEOUT_MS))
+    ]);
+    const bytes = hexToBytes(hex);
+    await saveMetadata(chainName, bytes);
+    return bytes;
+  } catch (err) {
+    if (err instanceof ConnectionError)
+      throw err;
+    throw new ConnectionError(`Failed to fetch metadata for "${chainName}": ${err instanceof Error ? err.message : err}. ` + "Check that the RPC endpoint is correct and reachable.");
   }
 }
-async function loadAccounts() {
-  await ensureDir2(getConfigDir());
-  if (await fileExists2(ACCOUNTS_PATH)) {
-    const data = await readFile2(ACCOUNTS_PATH, "utf-8");
-    return JSON.parse(data);
+async function getOrFetchMetadata(chainName, clientHandle) {
+  let raw = await loadMetadata(chainName);
+  if (!raw) {
+    if (!clientHandle) {
+      throw new MetadataError(`No cached metadata for chain "${chainName}". Run a command that connects to the chain first, ` + `e.g.: dot chain add ${chainName} --rpc <url>`);
+    }
+    raw = await fetchMetadataFromChain(clientHandle, chainName);
   }
-  return { accounts: [] };
-}
-async function saveAccounts(file) {
-  await ensureDir2(getConfigDir());
-  await writeFile2(ACCOUNTS_PATH, JSON.stringify(file, null, 2) + `
-`);
-}
-function findAccount(file, name) {
-  return file.accounts.find((a) => a.name.toLowerCase() === name.toLowerCase());
-}
-
-// src/core/accounts.ts
-import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
-import {
-  DEV_PHRASE,
-  mnemonicToEntropy,
-  entropyToMiniSecret,
-  generateMnemonic,
-  validateMnemonic,
-  ss58Address
-} from "@polkadot-labs/hdkd-helpers";
-import { getPolkadotSigner } from "polkadot-api/signer";
-var DEV_NAMES = [
-  "alice",
-  "bob",
-  "charlie",
-  "dave",
-  "eve",
-  "ferdie"
-];
-function isDevAccount(name) {
-  return DEV_NAMES.includes(name.toLowerCase());
-}
-function devDerivationPath(name) {
-  return "//" + name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+  return parseMetadata(raw);
 }
-function deriveFromMnemonic(mnemonic, path) {
-  const entropy = mnemonicToEntropy(mnemonic);
-  const miniSecret = entropyToMiniSecret(entropy);
-  const derive = sr25519CreateDerive(miniSecret);
-  return derive(path);
+function listPallets(meta) {
+  return meta.unified.pallets.map((p) => ({
+    name: p.name,
+    index: p.index,
+    docs: p.docs ?? [],
+    storage: (p.storage?.items ?? []).map((s) => ({
+      name: s.name,
+      docs: s.docs ?? [],
+      type: s.type.tag,
+      keyTypeId: s.type.tag === "map" ? s.type.value.key : null,
+      valueTypeId: s.type.tag === "plain" ? s.type.value : s.type.value.value
+    })),
+    constants: (p.constants ?? []).map((c) => ({
+      name: c.name,
+      docs: c.docs ?? [],
+      typeId: c.type
+    })),
+    calls: extractCalls(meta, p.calls)
+  }));
 }
-function deriveFromHexSeed(hexSeed, path) {
-  const clean = hexSeed.startsWith("0x") ? hexSeed.slice(2) : hexSeed;
-  const seed = new Uint8Array(clean.length / 2);
-  for (let i = 0;i < clean.length; i += 2) {
-    seed[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+function extractCalls(meta, callsRef) {
+  if (!callsRef)
+    return [];
+  try {
+    const entry = meta.lookup(callsRef.type);
+    if (entry.type !== "enum")
+      return [];
+    return Object.entries(entry.value).map(([name, variant]) => ({
+      name,
+      docs: variant.docs ?? [],
+      typeId: resolveCallTypeId(variant)
+    }));
+  } catch {
+    return [];
   }
-  const derive = sr25519CreateDerive(seed);
-  return derive(path);
 }
-function getDevKeypair(name) {
-  const path = devDerivationPath(name);
-  return deriveFromMnemonic(DEV_PHRASE, path);
+function resolveCallTypeId(variant) {
+  if (variant.type === "lookupEntry")
+    return variant.value?.id ?? null;
+  if (variant.type === "struct")
+    return null;
+  if (variant.type === "void" || variant.type === "empty")
+    return null;
+  return null;
 }
-function getDevAddress(name, prefix = 42) {
-  const keypair = getDevKeypair(name);
-  return ss58Address(keypair.publicKey, prefix);
+function findPallet(meta, palletName) {
+  const pallets = listPallets(meta);
+  return pallets.find((p) => p.name.toLowerCase() === palletName.toLowerCase());
 }
-function createNewAccount() {
-  const mnemonic = generateMnemonic();
-  const entropy = mnemonicToEntropy(mnemonic);
-  const miniSecret = entropyToMiniSecret(entropy);
-  const derive = sr25519CreateDerive(miniSecret);
-  const keypair = derive("");
-  return { mnemonic, publicKey: keypair.publicKey };
+function getSignedExtensions(meta) {
+  const byVersion = meta.unified.extrinsic.signedExtensions;
+  const versionKeys = Object.keys(byVersion);
+  if (versionKeys.length === 0)
+    return [];
+  return byVersion[Number(versionKeys[0])] ?? [];
 }
-function importAccount(secret) {
-  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(secret);
-  if (isHexSeed) {
-    const keypair2 = deriveFromHexSeed(secret, "");
-    return { publicKey: keypair2.publicKey };
-  }
-  if (!validateMnemonic(secret)) {
-    throw new Error("Invalid secret. Expected a 0x-prefixed 32-byte hex seed or a valid BIP39 mnemonic.");
-  }
-  const keypair = deriveFromMnemonic(secret, "");
-  return { publicKey: keypair.publicKey };
+function getPalletNames(meta) {
+  return meta.unified.pallets.map((p) => p.name);
 }
-function publicKeyToHex(publicKey) {
-  return "0x" + Array.from(publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+function describeType(lookup, typeId) {
+  try {
+    const entry = lookup(typeId);
+    return formatLookupEntry(entry);
+  } catch {
+    return `type(${typeId})`;
+  }
 }
-function toSs58(publicKey, prefix = 42) {
-  if (typeof publicKey === "string") {
-    const clean = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-    const bytes = new Uint8Array(clean.length / 2);
-    for (let i = 0;i < clean.length; i += 2) {
-      bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
+function formatLookupEntry(entry) {
+  switch (entry.type) {
+    case "primitive":
+      return entry.value;
+    case "compact":
+      return `Compact<${formatLookupEntry(entry.isBig ? { type: "primitive", value: "u128" } : { type: "primitive", value: "u64" })}>`;
+    case "AccountId32":
+      return "AccountId32";
+    case "bitSequence":
+      return "BitSequence";
+    case "sequence":
+      return `Vec<${formatLookupEntry(entry.value)}>`;
+    case "array":
+      return `[${formatLookupEntry(entry.value)}; ${entry.len}]`;
+    case "tuple":
+      return `(${entry.value.map(formatLookupEntry).join(", ")})`;
+    case "struct":
+      return `{ ${Object.entries(entry.value).map(([k, v]) => `${k}: ${formatLookupEntry(v)}`).join(", ")} }`;
+    case "option":
+      return `Option<${formatLookupEntry(entry.value)}>`;
+    case "result":
+      return `Result<${formatLookupEntry(entry.value.ok)}, ${formatLookupEntry(entry.value.ko)}>`;
+    case "enum": {
+      const variants = Object.keys(entry.value);
+      if (variants.length <= 4)
+        return variants.join(" | ");
+      return `enum(${variants.length} variants)`;
     }
-    return ss58Address(bytes, prefix);
+    default:
+      return "unknown";
   }
-  return ss58Address(publicKey, prefix);
 }
-async function resolveAccountSigner(name) {
-  if (isDevAccount(name)) {
-    const keypair2 = getDevKeypair(name);
-    return getPolkadotSigner(keypair2.publicKey, "Sr25519", keypair2.sign);
-  }
-  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(", ")}`);
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0;i < clean.length; i += 2) {
+    bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
   }
-  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(account.secret);
-  const keypair = isHexSeed ? deriveFromHexSeed(account.secret, account.derivationPath) : deriveFromMnemonic(account.secret, account.derivationPath);
-  return getPolkadotSigner(keypair.publicKey, "Sr25519", keypair.sign);
+  return bytes;
 }
 
-// src/commands/account.ts
-var ACCOUNT_HELP = `
+// src/commands/chain.ts
+var CHAIN_HELP = `
 ${BOLD}Usage:${RESET}
-  $ dot account create <name>                Create a new account
-  $ dot account import <name> --secret <s>   Import from mnemonic or hex seed
-  $ dot account list                         List all accounts
-  $ dot account remove <name>                Remove a stored account
+  $ 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 list                      List configured chains
+  $ dot chain default <name>            Set the default chain
 
 ${BOLD}Examples:${RESET}
-  $ dot account create my-validator
-  $ dot account import treasury --secret "word1 word2 ... word12"
-  $ dot account import raw-key --secret 0xabcdef...
-  $ dot account list
-  $ dot account remove my-validator
+  $ dot chain add kusama --rpc wss://kusama-rpc.polkadot.io
+  $ dot chain add westend --light-client
+  $ dot chain default kusama
+  $ dot chain list
+  $ dot chain update
+  $ dot chain update kusama
+  $ dot chain remove kusama
 `.trimStart();
-function registerAccountCommands(cli) {
-  cli.command("account [action] [name]", "Manage local accounts (create, import, list, remove)").option("--secret <value>", "Secret key (mnemonic or hex seed) for import").action(async (action, name, opts) => {
+function registerChainCommands(cli) {
+  cli.command("chain [action] [name]", "Manage chains (add, remove, update, list, default)").action(async (action, name, opts) => {
     if (!action) {
-      console.log(ACCOUNT_HELP);
+      console.log(CHAIN_HELP);
       return;
     }
     switch (action) {
-      case "create":
-        return accountCreate(name);
-      case "import":
-        return accountImport(name, opts);
-      case "list":
-        return accountList();
+      case "add":
+        return chainAdd(name, opts);
       case "remove":
-        return accountRemove(name);
+        return chainRemove(name);
+      case "list":
+        return chainList();
+      case "update":
+        return chainUpdate(name, opts);
+      case "default":
+        return chainDefault(name);
       default:
         console.error(`Unknown action "${action}".
 `);
-        console.log(ACCOUNT_HELP);
+        console.log(CHAIN_HELP);
         process.exit(1);
     }
   });
 }
-async function accountCreate(name) {
+async function chainAdd(name, opts) {
   if (!name) {
-    console.error(`Account name is required.
+    console.error(`Chain name is required.
 `);
-    console.error("Usage: dot account create <name>");
+    console.error("Usage: dot chain add <name> --rpc <url>");
+    console.error("       dot chain add <name> --light-client");
     process.exit(1);
   }
-  if (isDevAccount(name)) {
-    throw new Error(`"${name}" is a built-in dev account and cannot be used as a custom account name.`);
+  if (!opts.rpc && !opts.lightClient) {
+    console.error(`Must provide either --rpc <url> or --light-client.
+`);
+    console.error("Usage: dot chain add <name> --rpc <url>");
+    console.error("       dot chain add <name> --light-client");
+    process.exit(1);
   }
-  const accountsFile = await loadAccounts();
-  if (findAccount(accountsFile, name)) {
-    throw new Error(`Account "${name}" already exists.`);
+  const chainConfig = {
+    rpc: opts.rpc ?? "",
+    ...opts.lightClient ? { lightClient: true } : {}
+  };
+  console.log(`Connecting to ${name}...`);
+  const clientHandle = await createChainClient(name, chainConfig, opts.rpc);
+  try {
+    console.log("Fetching metadata...");
+    await fetchMetadataFromChain(clientHandle, name);
+    const config = await loadConfig();
+    config.chains[name] = chainConfig;
+    await saveConfig(config);
+    console.log(`Chain "${name}" added successfully.`);
+  } finally {
+    clientHandle.destroy();
   }
-  const { mnemonic, publicKey } = createNewAccount();
-  const hexPub = publicKeyToHex(publicKey);
-  const address = toSs58(publicKey);
-  accountsFile.accounts.push({
-    name,
-    secret: mnemonic,
-    publicKey: hexPub,
-    derivationPath: ""
-  });
-  await saveAccounts(accountsFile);
-  printHeading("Account Created");
-  console.log(`  ${BOLD}Name:${RESET}     ${name}`);
-  console.log(`  ${BOLD}Address:${RESET}  ${address}`);
-  console.log(`  ${BOLD}Mnemonic:${RESET} ${mnemonic}`);
-  console.log();
-  console.log(`  ${YELLOW}Save this mnemonic phrase! It is the only way to recover this account.${RESET}`);
-  console.log();
 }
-async function accountImport(name, opts) {
+async function chainRemove(name) {
   if (!name) {
-    console.error(`Account name is required.
-`);
-    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
+    console.error("Usage: dot chain remove <name>");
     process.exit(1);
   }
-  if (!opts.secret) {
-    console.error(`--secret is required.
-`);
-    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
+  const config = await loadConfig();
+  if (!config.chains[name]) {
+    throw new Error(`Chain "${name}" not found.`);
+  }
+  if (name === "polkadot") {
+    throw new Error('Cannot remove the built-in "polkadot" chain.');
+  }
+  delete config.chains[name];
+  if (config.defaultChain === name) {
+    config.defaultChain = "polkadot";
+    console.log(`Default chain reset to "polkadot".`);
+  }
+  await saveConfig(config);
+  await removeChainData(name);
+  console.log(`Chain "${name}" removed.`);
+}
+async function chainList() {
+  const config = await loadConfig();
+  printHeading("Configured Chains");
+  for (const [name, chainConfig] of Object.entries(config.chains)) {
+    const isDefault = name === config.defaultChain;
+    const marker = isDefault ? ` ${BOLD}(default)${RESET}` : "";
+    const provider = chainConfig.lightClient ? `${DIM}light-client${RESET}` : `${DIM}${chainConfig.rpc}${RESET}`;
+    console.log(`  ${CYAN}${name}${RESET}${marker}  ${provider}`);
+  }
+  console.log();
+}
+async function chainUpdate(name, opts) {
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, name);
+  console.log(`Connecting to ${chainName}...`);
+  const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+  try {
+    console.log("Fetching metadata...");
+    await fetchMetadataFromChain(clientHandle, chainName);
+    console.log(`Metadata for "${chainName}" updated.`);
+  } finally {
+    clientHandle.destroy();
+  }
+}
+async function chainDefault(name) {
+  if (!name) {
+    console.error("Usage: dot chain default <name>");
     process.exit(1);
   }
-  if (isDevAccount(name)) {
-    throw new Error(`"${name}" is a built-in dev account and cannot be used as a custom account name.`);
+  const config = await loadConfig();
+  if (!config.chains[name]) {
+    const available = Object.keys(config.chains).join(", ");
+    throw new Error(`Chain "${name}" not found. Available: ${available}`);
   }
-  const accountsFile = await loadAccounts();
-  if (findAccount(accountsFile, name)) {
-    throw new Error(`Account "${name}" already exists.`);
+  config.defaultChain = name;
+  await saveConfig(config);
+  console.log(`Default chain set to "${name}".`);
+}
+
+// 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);
+    }
   }
-  const { publicKey } = importAccount(opts.secret);
-  const hexPub = publicKeyToHex(publicKey);
-  const address = toSs58(publicKey);
-  accountsFile.accounts.push({
-    name,
-    secret: opts.secret,
-    publicKey: hexPub,
-    derivationPath: ""
+  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/utils/parse-target.ts
+function parseTarget(input) {
+  const parts = input.split(".");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid target "${input}". Expected format: Pallet.Item (e.g. System.Account)`);
+  }
+  return { pallet: parts[0], item: parts[1] };
+}
+
+// src/commands/const.ts
+function registerConstCommand(cli) {
+  cli.command("const [target]", "Look up a pallet constant (e.g. Balances.ExistentialDeposit)").action(async (target, opts) => {
+    if (!target) {
+      console.log("Usage: dot const <Pallet.Constant> [--chain <name>] [--output json]");
+      console.log("");
+      console.log("Examples:");
+      console.log("  $ dot const Balances.ExistentialDeposit");
+      console.log("  $ dot const System.SS58Prefix --chain kusama");
+      return;
+    }
+    const config = await loadConfig();
+    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+    const { pallet, item } = parseTarget(target);
+    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+    try {
+      const meta = await getOrFetchMetadata(chainName, clientHandle);
+      const palletNames = getPalletNames(meta);
+      const palletInfo = findPallet(meta, pallet);
+      if (!palletInfo) {
+        throw new Error(suggestMessage("pallet", pallet, palletNames));
+      }
+      const constantItem = palletInfo.constants.find((c) => c.name.toLowerCase() === item.toLowerCase());
+      if (!constantItem) {
+        const constNames = palletInfo.constants.map((c) => c.name);
+        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);
+      printResult(result, opts.output ?? "pretty");
+    } finally {
+      clientHandle.destroy();
+    }
   });
-  await saveAccounts(accountsFile);
-  printHeading("Account Imported");
-  console.log(`  ${BOLD}Name:${RESET}    ${name}`);
-  console.log(`  ${BOLD}Address:${RESET} ${address}`);
-  console.log();
 }
-async function accountList() {
-  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);
+
+// src/core/hash.ts
+import { blake2b } from "@noble/hashes/blake2.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+var ALGORITHMS = {
+  blake2b256: {
+    compute: (data) => blake2b(data, { dkLen: 32 }),
+    outputLen: 32,
+    description: "BLAKE2b with 256-bit output"
+  },
+  blake2b128: {
+    compute: (data) => blake2b(data, { dkLen: 16 }),
+    outputLen: 16,
+    description: "BLAKE2b with 128-bit output"
+  },
+  keccak256: {
+    compute: (data) => keccak_256(data),
+    outputLen: 32,
+    description: "Keccak-256 (Ethereum-compatible)"
+  },
+  sha256: {
+    compute: (data) => sha256(data),
+    outputLen: 32,
+    description: "SHA-256"
   }
-  const accountsFile = await loadAccounts();
-  if (accountsFile.accounts.length > 0) {
-    printHeading("Stored Accounts");
-    for (const account of accountsFile.accounts) {
-      const address = toSs58(account.publicKey);
-      printItem(account.name, address);
+};
+function computeHash(algorithm, data) {
+  const algo = ALGORITHMS[algorithm];
+  if (!algo) {
+    throw new Error(`Unknown algorithm: ${algorithm}`);
+  }
+  return algo.compute(data);
+}
+function parseInputData(input) {
+  if (input.startsWith("0x")) {
+    const hex = input.slice(2);
+    if (hex.length % 2 !== 0) {
+      throw new Error(`Invalid hex input: odd number of characters`);
+    }
+    return hexToBytes2(hex);
+  }
+  return new TextEncoder().encode(input);
+}
+function toHex(bytes) {
+  return `0x${bytesToHex(bytes)}`;
+}
+function isValidAlgorithm(name) {
+  return name in ALGORITHMS;
+}
+function getAlgorithmNames() {
+  return Object.keys(ALGORITHMS);
+}
+
+// src/commands/hash.ts
+async function resolveInput(data, opts) {
+  const sources = [data !== undefined, !!opts.file, !!opts.stdin].filter(Boolean).length;
+  if (sources > 1) {
+    throw new CliError("Provide only one of: inline data, --file, or --stdin");
+  }
+  if (sources === 0) {
+    throw new CliError("No input provided. Pass data as argument, or use --file or --stdin");
+  }
+  if (opts.file) {
+    const buf = await Bun.file(opts.file).arrayBuffer();
+    return new Uint8Array(buf);
+  }
+  if (opts.stdin) {
+    const reader = Bun.stdin.stream().getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+    }
+    const totalLen = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  return parseInputData(data);
+}
+function printAlgorithmHelp() {
+  console.log(`${BOLD}Usage:${RESET} dot hash <algorithm> <data> [options]
+`);
+  console.log(`${BOLD}Algorithms:${RESET}`);
+  for (const [name, algo] of Object.entries(ALGORITHMS)) {
+    console.log(`  ${CYAN}${name}${RESET}  ${DIM}${algo.description} (${algo.outputLen} bytes)${RESET}`);
+  }
+  console.log(`
+${BOLD}Options:${RESET}`);
+  console.log(`  ${CYAN}--file <path>${RESET}   ${DIM}Hash file contents${RESET}`);
+  console.log(`  ${CYAN}--stdin${RESET}          ${DIM}Read from stdin${RESET}`);
+  console.log(`  ${CYAN}--output json${RESET}    ${DIM}Output as JSON${RESET}`);
+  console.log(`
+${BOLD}Examples:${RESET}`);
+  console.log(`  ${DIM}$ dot hash blake2b256 0xdeadbeef${RESET}`);
+  console.log(`  ${DIM}$ dot hash sha256 hello${RESET}`);
+  console.log(`  ${DIM}$ dot hash keccak256 --file ./data.bin${RESET}`);
+  console.log(`  ${DIM}$ echo -n "hello" | dot hash sha256 --stdin${RESET}`);
+}
+function registerHashCommand(cli) {
+  cli.command("hash [algorithm] [data]", "Compute cryptographic hashes").option("--file <path>", "Hash file contents (raw bytes)").option("--stdin", "Read data from stdin").action(async (algorithm, data, opts) => {
+    if (!algorithm) {
+      printAlgorithmHelp();
+      return;
+    }
+    if (!isValidAlgorithm(algorithm)) {
+      throw new CliError(suggestMessage("algorithm", algorithm, getAlgorithmNames()));
+    }
+    const input = await resolveInput(data, opts);
+    const hash = computeHash(algorithm, input);
+    const hexHash = toHex(hash);
+    const format = opts.output ?? "pretty";
+    if (format === "json") {
+      printResult({
+        algorithm,
+        input: data ?? (opts.file ? `file:${opts.file}` : "stdin"),
+        hash: hexHash
+      }, "json");
+    } else {
+      console.log(hexHash);
+    }
+  });
+}
+
+// src/commands/inspect.ts
+function registerInspectCommand(cli) {
+  cli.command("inspect [target]", "Inspect chain metadata (pallets, storage, constants)").option("--chain <name>", "Target chain").option("--rpc <url>", "Override RPC endpoint").action(async (target, opts) => {
+    const config = await loadConfig();
+    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+    let meta;
+    try {
+      meta = await getOrFetchMetadata(chainName);
+    } catch {
+      console.log(`Fetching metadata from ${chainName}...`);
+      const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+      try {
+        meta = await getOrFetchMetadata(chainName, clientHandle);
+      } finally {
+        clientHandle.destroy();
+      }
+    }
+    if (!target) {
+      const pallets = listPallets(meta);
+      printHeading(`Pallets on ${chainName} (${pallets.length})`);
+      for (const p of pallets) {
+        const counts = [];
+        if (p.storage.length)
+          counts.push(`${p.storage.length} storage`);
+        if (p.constants.length)
+          counts.push(`${p.constants.length} constants`);
+        printItem(p.name, counts.join(", "));
+      }
+      console.log();
+      return;
+    }
+    if (!target.includes(".")) {
+      const palletNames2 = getPalletNames(meta);
+      const pallet2 = findPallet(meta, target);
+      if (!pallet2) {
+        throw new Error(suggestMessage("pallet", target, palletNames2));
+      }
+      printHeading(`${pallet2.name} Pallet`);
+      if (pallet2.docs.length) {
+        printDocs(pallet2.docs);
+        console.log();
+      }
+      if (pallet2.storage.length) {
+        console.log(`  ${BOLD}Storage Items:${RESET}`);
+        for (const s of pallet2.storage) {
+          const doc = s.docs[0] ? ` — ${s.docs[0].slice(0, 80)}` : "";
+          console.log(`    ${CYAN}${s.name}${RESET}${DIM}${doc}${RESET}`);
+        }
+        console.log();
+      }
+      if (pallet2.constants.length) {
+        console.log(`  ${BOLD}Constants:${RESET}`);
+        for (const c of pallet2.constants) {
+          const doc = c.docs[0] ? ` — ${c.docs[0].slice(0, 80)}` : "";
+          console.log(`    ${CYAN}${c.name}${RESET}${DIM}${doc}${RESET}`);
+        }
+        console.log();
+      }
+      return;
+    }
+    const { pallet: palletName, item: itemName } = parseTarget(target);
+    const palletNames = getPalletNames(meta);
+    const pallet = findPallet(meta, palletName);
+    if (!pallet) {
+      throw new Error(suggestMessage("pallet", palletName, palletNames));
+    }
+    const storageItem = pallet.storage.find((s) => s.name.toLowerCase() === itemName.toLowerCase());
+    if (storageItem) {
+      printHeading(`${pallet.name}.${storageItem.name} (Storage)`);
+      console.log(`  ${BOLD}Type:${RESET} ${storageItem.type}`);
+      console.log(`  ${BOLD}Value:${RESET} ${describeType(meta.lookup, storageItem.valueTypeId)}`);
+      if (storageItem.keyTypeId != null) {
+        console.log(`  ${BOLD}Key:${RESET} ${describeType(meta.lookup, storageItem.keyTypeId)}`);
+      }
+      if (storageItem.docs.length) {
+        console.log();
+        printDocs(storageItem.docs);
+      }
+      console.log();
+      return;
+    }
+    const constantItem = pallet.constants.find((c) => c.name.toLowerCase() === itemName.toLowerCase());
+    if (constantItem) {
+      printHeading(`${pallet.name}.${constantItem.name} (Constant)`);
+      console.log(`  ${BOLD}Type:${RESET} ${describeType(meta.lookup, constantItem.typeId)}`);
+      if (constantItem.docs.length) {
+        console.log();
+        printDocs(constantItem.docs);
+      }
+      console.log();
+      return;
     }
-  } else {
-    printHeading("Stored Accounts");
-    console.log("  (none)");
-  }
-  console.log();
+    const allItems = [
+      ...pallet.storage.map((s) => s.name),
+      ...pallet.constants.map((c) => c.name)
+    ];
+    throw new Error(suggestMessage(`item in ${pallet.name}`, itemName, allItems));
+  });
 }
-async function accountRemove(name) {
-  if (!name) {
-    console.error(`Account name is required.
-`);
-    console.error("Usage: dot account remove <name>");
-    process.exit(1);
-  }
-  if (isDevAccount(name)) {
-    throw new Error("Cannot remove built-in dev accounts.");
-  }
-  const accountsFile = await loadAccounts();
-  const idx = accountsFile.accounts.findIndex((a) => a.name.toLowerCase() === name.toLowerCase());
-  if (idx === -1) {
-    throw new Error(`Account "${name}" not found.`);
+
+// src/utils/parse-value.ts
+function parseValue(arg) {
+  if (/^\d+$/.test(arg))
+    return parseInt(arg, 10);
+  if (/^\d{16,}$/.test(arg))
+    return BigInt(arg);
+  if (/^0x[0-9a-fA-F]+$/.test(arg))
+    return arg;
+  if (arg === "true")
+    return true;
+  if (arg === "false")
+    return false;
+  if (arg.startsWith("{") || arg.startsWith("[")) {
+    try {
+      return JSON.parse(arg);
+    } catch {}
   }
-  accountsFile.accounts.splice(idx, 1);
-  await saveAccounts(accountsFile);
-  console.log(`Account "${name}" removed.`);
+  return arg;
+}
+
+// src/commands/query.ts
+var DEFAULT_LIMIT = 100;
+function registerQueryCommand(cli) {
+  cli.command("query [target] [...keys]", "Query on-chain storage (e.g. System.Number, System.Account <addr>)").option("--limit <n>", "Max entries to return for map queries (0 = unlimited)", {
+    default: DEFAULT_LIMIT
+  }).action(async (target, keys, opts) => {
+    if (!target) {
+      console.log("Usage: dot query <Pallet.Item> [...keys] [--chain <name>] [--output json]");
+      console.log("");
+      console.log("Examples:");
+      console.log("  $ dot query System.Number                         # plain storage value");
+      console.log("  $ dot query System.Account 5Grw...                # single map entry");
+      console.log("  $ dot query System.Account                        # all entries (limit 100)");
+      console.log("  $ dot query System.Account --limit 10             # first 10 entries");
+      console.log("  $ dot query System.Account --limit 0              # all entries (no limit)");
+      console.log("  $ dot query Assets.Metadata 42 --chain asset-hub");
+      return;
+    }
+    const config = await loadConfig();
+    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+    const { pallet, item } = parseTarget(target);
+    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+    try {
+      const meta = await getOrFetchMetadata(chainName, clientHandle);
+      const palletNames = getPalletNames(meta);
+      const palletInfo = findPallet(meta, pallet);
+      if (!palletInfo) {
+        throw new Error(suggestMessage("pallet", pallet, palletNames));
+      }
+      const storageItem = palletInfo.storage.find((s) => s.name.toLowerCase() === item.toLowerCase());
+      if (!storageItem) {
+        const storageNames = palletInfo.storage.map((s) => s.name);
+        throw new Error(suggestMessage(`storage item in ${palletInfo.name}`, item, storageNames));
+      }
+      const unsafeApi = clientHandle.client.getUnsafeApi();
+      const storageApi = unsafeApi.query[palletInfo.name][storageItem.name];
+      const parsedKeys = keys.map(parseValue);
+      const format = opts.output ?? "pretty";
+      if (storageItem.type === "map" && parsedKeys.length === 0) {
+        const entries = await storageApi.getEntries();
+        const limit = Number(opts.limit);
+        const truncated = limit > 0 && entries.length > limit;
+        const display = truncated ? entries.slice(0, limit) : entries;
+        printResult(display.map((e) => ({
+          keys: e.keyArgs,
+          value: e.value
+        })), format);
+        if (truncated) {
+          console.error(`
+${DIM}Showing ${limit} of ${entries.length} entries. Use --limit 0 for all.${RESET}`);
+        }
+      } else {
+        const result = await storageApi.getValue(...parsedKeys);
+        printResult(result, format);
+      }
+    } finally {
+      clientHandle.destroy();
+    }
+  });
 }
 
 // src/commands/tx.ts
-import { Binary } from "polkadot-api";
 import { getViewBuilder } from "@polkadot-api/view-builder";
+import { Binary } from "polkadot-api";
 
 // src/core/explorers.ts
 var pjsAppsLink = (rpc, hash) => `https://polkadot.js.org/apps/?rpc=${encodeURIComponent(rpc)}#/explorer/query/${hash}`;
@@ -1138,7 +1263,7 @@ function registerTxCommand(cli) {
         const userExtOverrides = parseExtOption(opts.ext);
         const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
         txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
-        unsafeApi = clientHandle.client.getUnsafeApi();
+        unsafeApi = clientHandle?.client.getUnsafeApi();
       }
       let tx;
       let callHex;
@@ -1166,11 +1291,7 @@ function registerTxCommand(cli) {
         if (opts.encode) {
           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 fullCall = new Uint8Array([location[0], location[1], ...encodedArgs]);
           console.log(Binary.fromBytes(fullCall).asHex());
           return;
         }
@@ -1181,11 +1302,12 @@ function registerTxCommand(cli) {
       const decodedStr = decodeCall(meta, callHex);
       if (opts.dryRun) {
         const signerAddress = toSs58(signer.publicKey);
+        console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
         console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
         console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
         console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
         try {
-          const fees = await tx.getEstimatedFees(signer.publicKey, txOptions);
+          const fees = await tx.getEstimatedFees(signer?.publicKey, txOptions);
           console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
         } catch (err) {
           console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
@@ -1195,15 +1317,17 @@ function registerTxCommand(cli) {
       }
       const result = await watchTransaction(tx.signSubmitAndWatch(signer, txOptions));
       console.log();
+      console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
       console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
       console.log(`  ${BOLD}Tx:${RESET}     ${result.txHash}`);
-      console.log(`  ${BOLD}Block:${RESET}  #${result.block.number} (${result.block.hash})`);
+      let dispatchErrorMsg;
       if (result.ok) {
         console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}`);
       } else {
-        console.log(`  ${BOLD}Status:${RESET} ${YELLOW}dispatch error${RESET}`);
-        console.log(`  ${BOLD}Error:${RESET}  ${result.dispatchError.type}${result.dispatchError.value ? ": " + JSON.stringify(result.dispatchError.value) : ""}`);
+        dispatchErrorMsg = formatDispatchError(result.dispatchError);
+        console.log(`  ${BOLD}Status:${RESET} ${RED}dispatch error${RESET}`);
+        console.log(`  ${BOLD}Error:${RESET}  ${dispatchErrorMsg}`);
       }
       if (result.events && result.events.length > 0) {
         console.log(`  ${BOLD}Events:${RESET}`);
@@ -1226,11 +1350,31 @@ function registerTxCommand(cli) {
         console.log(`    ${DIM}PAPI${RESET}        ${papiLink(rpcUrl, blockHash)}`);
       }
       console.log();
+      if (!result.ok) {
+        throw new CliError(`Transaction dispatch error: ${dispatchErrorMsg}`);
+      }
     } finally {
       clientHandle?.destroy();
     }
   });
 }
+function formatDispatchError(err) {
+  if (err.type === "Module" && err.value && typeof err.value === "object") {
+    const mod = err.value;
+    if (mod.type) {
+      const inner = mod.value;
+      if (inner && typeof inner === "object" && inner.type) {
+        return `${mod.type}.${inner.type}`;
+      }
+      return mod.type;
+    }
+  }
+  if (err.value !== undefined && err.value !== null) {
+    const val = typeof err.value === "string" ? err.value : JSON.stringify(err.value);
+    return `${err.type}: ${val}`;
+  }
+  return err.type;
+}
 function decodeCall(meta, callHex) {
   try {
     const viewBuilder = getViewBuilder(meta.lookup);
@@ -1432,6 +1576,15 @@ function normalizeValue(lookup, entry, value) {
     }
     case "array":
     case "sequence": {
+      let innerResolved = resolved.value;
+      while (innerResolved.type === "lookupEntry") {
+        innerResolved = innerResolved.value;
+      }
+      if (innerResolved.type === "primitive" && innerResolved.value === "u8" && typeof value === "string") {
+        if (/^0x[0-9a-fA-F]*$/.test(value))
+          return Binary.fromHex(value);
+        return Binary.fromText(value);
+      }
       if (Array.isArray(value)) {
         const innerEntry = resolved.value;
         return value.map((item) => normalizeValue(lookup, innerEntry, item));
@@ -1449,6 +1602,36 @@ function normalizeValue(lookup, entry, value) {
       if (value !== null && value !== undefined) {
         return normalizeValue(lookup, resolved.value, value);
       }
+      return;
+    }
+    case "primitive": {
+      if (typeof value === "string") {
+        const prim = resolved.value;
+        switch (prim) {
+          case "bool":
+            return value === "true";
+          case "u64":
+          case "u128":
+          case "u256":
+          case "i64":
+          case "i128":
+          case "i256":
+            return BigInt(value);
+          case "u8":
+          case "u16":
+          case "u32":
+          case "i8":
+          case "i16":
+          case "i32":
+            return parseInt(value, 10);
+        }
+      }
+      return value;
+    }
+    case "compact": {
+      if (typeof value === "string") {
+        return resolved.isBig ? BigInt(value) : parseInt(value, 10);
+      }
       return value;
     }
     default:
@@ -1482,7 +1665,7 @@ function parseTypedArg(meta, entry, arg) {
       }
       const variants = Object.keys(entry.value);
       if (variants.includes("Id")) {
-        const idVariant = entry.value["Id"];
+        const idVariant = entry.value.Id;
         const innerType = idVariant.type === "lookupEntry" ? idVariant.value : idVariant;
         if (innerType.type === "AccountId32" && !arg.startsWith("{")) {
           return { type: "Id", value: arg };
@@ -1649,7 +1832,7 @@ function watchTransaction(observable) {
             }
             break;
           case "finalized":
-            spinner.stop();
+            spinner.succeed(`Finalized in block #${event.block.number}`);
             resolve(event);
             break;
         }
@@ -1662,133 +1845,6 @@ function watchTransaction(observable) {
   });
 }
 
-// src/core/hash.ts
-import { blake2b } from "@noble/hashes/blake2.js";
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { bytesToHex, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
-var ALGORITHMS = {
-  blake2b256: {
-    compute: (data) => blake2b(data, { dkLen: 32 }),
-    outputLen: 32,
-    description: "BLAKE2b with 256-bit output"
-  },
-  blake2b128: {
-    compute: (data) => blake2b(data, { dkLen: 16 }),
-    outputLen: 16,
-    description: "BLAKE2b with 128-bit output"
-  },
-  keccak256: {
-    compute: (data) => keccak_256(data),
-    outputLen: 32,
-    description: "Keccak-256 (Ethereum-compatible)"
-  },
-  sha256: {
-    compute: (data) => sha256(data),
-    outputLen: 32,
-    description: "SHA-256"
-  }
-};
-function computeHash(algorithm, data) {
-  const algo = ALGORITHMS[algorithm];
-  if (!algo) {
-    throw new Error(`Unknown algorithm: ${algorithm}`);
-  }
-  return algo.compute(data);
-}
-function parseInputData(input) {
-  if (input.startsWith("0x")) {
-    const hex = input.slice(2);
-    if (hex.length % 2 !== 0) {
-      throw new Error(`Invalid hex input: odd number of characters`);
-    }
-    return hexToBytes2(hex);
-  }
-  return new TextEncoder().encode(input);
-}
-function toHex(bytes) {
-  return "0x" + bytesToHex(bytes);
-}
-function isValidAlgorithm(name) {
-  return name in ALGORITHMS;
-}
-function getAlgorithmNames() {
-  return Object.keys(ALGORITHMS);
-}
-
-// src/commands/hash.ts
-async function resolveInput(data, opts) {
-  const sources = [data !== undefined, !!opts.file, !!opts.stdin].filter(Boolean).length;
-  if (sources > 1) {
-    throw new CliError("Provide only one of: inline data, --file, or --stdin");
-  }
-  if (sources === 0) {
-    throw new CliError("No input provided. Pass data as argument, or use --file or --stdin");
-  }
-  if (opts.file) {
-    const buf = await Bun.file(opts.file).arrayBuffer();
-    return new Uint8Array(buf);
-  }
-  if (opts.stdin) {
-    const reader = Bun.stdin.stream().getReader();
-    const chunks = [];
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      chunks.push(value);
-    }
-    const totalLen = chunks.reduce((sum, c) => sum + c.length, 0);
-    const result = new Uint8Array(totalLen);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
-  }
-  return parseInputData(data);
-}
-function printAlgorithmHelp() {
-  console.log(`${BOLD}Usage:${RESET} dot hash <algorithm> <data> [options]
-`);
-  console.log(`${BOLD}Algorithms:${RESET}`);
-  for (const [name, algo] of Object.entries(ALGORITHMS)) {
-    console.log(`  ${CYAN}${name}${RESET}  ${DIM}${algo.description} (${algo.outputLen} bytes)${RESET}`);
-  }
-  console.log(`
-${BOLD}Options:${RESET}`);
-  console.log(`  ${CYAN}--file <path>${RESET}   ${DIM}Hash file contents${RESET}`);
-  console.log(`  ${CYAN}--stdin${RESET}          ${DIM}Read from stdin${RESET}`);
-  console.log(`  ${CYAN}--output json${RESET}    ${DIM}Output as JSON${RESET}`);
-  console.log(`
-${BOLD}Examples:${RESET}`);
-  console.log(`  ${DIM}$ dot hash blake2b256 0xdeadbeef${RESET}`);
-  console.log(`  ${DIM}$ dot hash sha256 hello${RESET}`);
-  console.log(`  ${DIM}$ dot hash keccak256 --file ./data.bin${RESET}`);
-  console.log(`  ${DIM}$ echo -n "hello" | dot hash sha256 --stdin${RESET}`);
-}
-function registerHashCommand(cli) {
-  cli.command("hash [algorithm] [data]", "Compute cryptographic hashes").option("--file <path>", "Hash file contents (raw bytes)").option("--stdin", "Read data from stdin").action(async (algorithm, data, opts) => {
-    if (!algorithm) {
-      printAlgorithmHelp();
-      return;
-    }
-    if (!isValidAlgorithm(algorithm)) {
-      throw new CliError(suggestMessage("algorithm", algorithm, getAlgorithmNames()));
-    }
-    const input = await resolveInput(data, opts);
-    const hash = computeHash(algorithm, input);
-    const hexHash = toHex(hash);
-    const format = opts.output ?? "pretty";
-    if (format === "json") {
-      printResult({ algorithm, input: data ?? (opts.file ? `file:${opts.file}` : "stdin"), hash: hexHash }, "json");
-    } else {
-      console.log(hexHash);
-    }
-  });
-}
-
 // src/utils/errors.ts
 class CliError2 extends Error {
   constructor(message) {
@@ -1796,8 +1852,6 @@ class CliError2 extends Error {
     this.name = "CliError";
   }
 }
-// package.json
-var version = "0.6.0";
 
 // src/cli.ts
 var cli = cac("dot");