polkadot-cli 0.1.2 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # polkadot-cli
 
-A command-line tool for querying Polkadot-ecosystem on-chain state. Query storage, look up constants, and inspect chain metadata — all from your terminal.
+A command-line tool for interacting with Polkadot-ecosystem chains. Query storage, look up constants, inspect metadata, manage accounts, and submit extrinsics — all from your terminal.
 
 Ships with Polkadot as the default chain. Add any Substrate-based chain by pointing to its RPC endpoint.
 
@@ -52,6 +52,45 @@ dot inspect System
 dot inspect System.Account
 ```
 
+### Manage accounts
+
+Dev accounts (Alice, Bob, Charlie, Dave, Eve, Ferdie) are always available for testnets. Create or import your own accounts for any chain.
+
+```bash
+# List all accounts (dev + stored)
+dot account list
+
+# Create a new account (generates a mnemonic)
+dot account create my-validator
+
+# Import from a BIP39 mnemonic
+dot account import treasury --secret "word1 word2 ... word12"
+
+# Import from a hex seed
+dot account import raw-key --secret 0xabcdef...
+
+# Remove an account
+dot account remove my-validator
+```
+
+### Submit extrinsics
+
+Build, sign, and submit transactions. Arguments are parsed from metadata — the CLI knows the expected types for each call.
+
+```bash
+# Simple remark
+dot tx System.remark 0xdeadbeef --from alice
+
+# Transfer (amount in plancks)
+dot tx Balances.transferKeepAlive 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty 1000000000000 --from alice
+
+# Estimate fees without submitting
+dot tx Balances.transferKeepAlive 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty 1000000000000 --from alice --dry-run
+
+# Batch multiple transfers with Utility.batchAll
+dot tx Utility.batchAll '[{"type":"Balances","value":{"type":"transfer_keep_alive","value":{"dest":"5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty","value":1000000000000}}},{"type":"Balances","value":{"type":"transfer_keep_alive","value":{"dest":"5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y","value":2000000000000}}}]' --from alice
+```
+
 ### Manage chains
 
 ```bash
@@ -90,6 +129,7 @@ Config and metadata caches live in `~/.polkadot/`:
 ```
 ~/.polkadot/
 ├── config.json          # chains and default chain
+├── accounts.json        # stored accounts (secrets encrypted at rest — coming soon)
 └── chains/
     └── polkadot/
         └── metadata.bin # cached SCALE-encoded metadata

package/dist/cli.mjs

@@ -40,6 +40,9 @@ var DEFAULT_CONFIG = {
 var DOT_DIR = join(homedir(), ".polkadot");
 var CONFIG_PATH = join(DOT_DIR, "config.json");
 var CHAINS_DIR = join(DOT_DIR, "chains");
+function getConfigDir() {
+  return DOT_DIR;
+}
 function getChainDir(chainName) {
   return join(CHAINS_DIR, chainName);
 }
@@ -131,17 +134,30 @@ var KNOWN_CHAIN_SPECS = {
   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));
+    provider = withPolkadotSdkCompat(getWsProvider(rpc, { timeout: 1e4 }));
   }
   const client = createClient(provider, {
     getMetadata: async () => loadMetadata(chainName),
@@ -151,7 +167,10 @@ async function createChainClient(chainName, chainConfig, rpcOverride) {
   });
   return {
     client,
-    destroy: () => client.destroy()
+    destroy: () => {
+      client.destroy();
+      restoreConsole();
+    }
   };
 }
 async function createSmoldotProvider(chainName) {
@@ -173,6 +192,7 @@ import {
   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);
@@ -182,10 +202,19 @@ function parseMetadata(raw) {
 }
 async function fetchMetadataFromChain(clientHandle, chainName) {
   const { client } = clientHandle;
-  const hex = await client._request("state_getMetadata", []);
-  const bytes = hexToBytes(hex);
-  await saveMetadata(chainName, bytes);
-  return bytes;
+  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.");
+  }
 }
 async function getOrFetchMetadata(chainName, clientHandle) {
   let raw = await loadMetadata(chainName);
@@ -213,9 +242,35 @@ function listPallets(meta) {
       name: c.name,
       docs: c.docs ?? [],
       typeId: c.type
-    }))
+    })),
+    calls: extractCalls(meta, p.calls)
   }));
 }
+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 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 findPallet(meta, palletName) {
   const pallets = listPallets(meta);
   return pallets.find((p) => p.name.toLowerCase() === palletName.toLowerCase());
@@ -386,17 +441,18 @@ async function chainAdd(name, opts) {
     console.error("       dot chain add <name> --light-client");
     process.exit(1);
   }
-  const config = await loadConfig();
-  config.chains[name] = {
+  const chainConfig = {
     rpc: opts.rpc ?? "",
     ...opts.lightClient ? { lightClient: true } : {}
   };
-  await saveConfig(config);
   console.log(`Connecting to ${name}...`);
-  const clientHandle = await createChainClient(name, config.chains[name], opts.rpc);
+  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();
@@ -607,6 +663,26 @@ function registerInspectCommand(cli) {
   });
 }
 
+// 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 {}
+  }
+  return arg;
+}
+
 // src/commands/query.ts
 var DEFAULT_LIMIT = 100;
 function registerQueryCommand(cli) {
@@ -643,7 +719,7 @@ function registerQueryCommand(cli) {
       }
       const unsafeApi = clientHandle.client.getUnsafeApi();
       const storageApi = unsafeApi.query[palletInfo.name][storageItem.name];
-      const parsedKeys = keys.map(parseKeyArg);
+      const parsedKeys = keys.map(parseValue);
       const format = opts.output ?? "pretty";
       if (storageItem.type === "map" && parsedKeys.length === 0) {
         const entries = await storageApi.getEntries();
@@ -667,24 +743,6 @@ ${DIM}Showing ${limit} of ${entries.length} entries. Use --limit 0 for all.${RES
     }
   });
 }
-function parseKeyArg(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 {}
-  }
-  return arg;
-}
 
 // src/commands/const.ts
 function registerConstCommand(cli) {
@@ -723,6 +781,512 @@ function registerConstCommand(cli) {
   });
 }
 
+// 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 });
+}
+async function fileExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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: [] };
+}
+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();
+}
+function deriveFromMnemonic(mnemonic, path) {
+  const entropy = mnemonicToEntropy(mnemonic);
+  const miniSecret = entropyToMiniSecret(entropy);
+  const derive = sr25519CreateDerive(miniSecret);
+  return derive(path);
+}
+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 getDevKeypair(name) {
+  const path = devDerivationPath(name);
+  return deriveFromMnemonic(DEV_PHRASE, path);
+}
+function getDevAddress(name, prefix = 42) {
+  const keypair = getDevKeypair(name);
+  return ss58Address(keypair.publicKey, prefix);
+}
+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 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 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);
+}
+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(", ")}`);
+  }
+  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/commands/account.ts
+var ACCOUNT_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
+
+${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
+`.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) => {
+    if (!action) {
+      console.log(ACCOUNT_HELP);
+      return;
+    }
+    switch (action) {
+      case "create":
+        return accountCreate(name);
+      case "import":
+        return accountImport(name, opts);
+      case "list":
+        return accountList();
+      case "remove":
+        return accountRemove(name);
+      default:
+        console.error(`Unknown action "${action}".
+`);
+        console.log(ACCOUNT_HELP);
+        process.exit(1);
+    }
+  });
+}
+async function accountCreate(name) {
+  if (!name) {
+    console.error(`Account name is required.
+`);
+    console.error("Usage: dot account create <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 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 accountImport(name, opts) {
+  if (!name) {
+    console.error(`Account name is required.
+`);
+    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
+    process.exit(1);
+  }
+  if (!opts.secret) {
+    console.error(`--secret is required.
+`);
+    console.error('Usage: dot account import <name> --secret "mnemonic or hex seed"');
+    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 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 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 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.`);
+  }
+  accountsFile.accounts.splice(idx, 1);
+  await saveAccounts(accountsFile);
+  console.log(`Account "${name}" removed.`);
+}
+
+// src/commands/tx.ts
+function registerTxCommand(cli) {
+  cli.command("tx [target] [...args]", "Submit an extrinsic (e.g. Balances.transferKeepAlive <dest> <amount>)").option("--from <name>", "Account to sign with (required)").option("--dry-run", "Estimate fees without submitting").action(async (target, args, opts) => {
+    if (!target || !opts.from) {
+      console.log("Usage: dot tx <Pallet.Call> [...args] --from <account> [--dry-run]");
+      console.log("");
+      console.log("Examples:");
+      console.log("  $ dot tx Balances.transferKeepAlive 5FHn... 1000000000000 --from alice");
+      console.log("  $ dot tx System.remark 0xdeadbeef --from alice --dry-run");
+      return;
+    }
+    const config = await loadConfig();
+    const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+    const { pallet, item: callName } = parseTarget(target);
+    const signer = await resolveAccountSigner(opts.from);
+    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 callInfo = palletInfo.calls.find((c) => c.name.toLowerCase() === callName.toLowerCase());
+      if (!callInfo) {
+        const callNames = palletInfo.calls.map((c) => c.name);
+        throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
+      }
+      const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
+      const unsafeApi = clientHandle.client.getUnsafeApi();
+      const tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
+      if (opts.dryRun) {
+        const signerAddress = toSs58(signer.publicKey);
+        console.log(`  ${BOLD}From:${RESET} ${opts.from} (${signerAddress})`);
+        try {
+          const fees = await tx.getEstimatedFees(signer.publicKey);
+          console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
+        } catch (err) {
+          console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
+          console.log(`  ${DIM}${err.message ?? err}${RESET}`);
+        }
+        return;
+      }
+      console.log("Signing and submitting...");
+      const result = await tx.signAndSubmit(signer);
+      console.log();
+      console.log(`  ${BOLD}Tx:${RESET}     ${result.txHash}`);
+      if (result.block) {
+        console.log(`  ${BOLD}Block:${RESET}  #${result.block.number} (${result.block.hash})`);
+      }
+      if (result.dispatchError) {
+        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) : ""}`);
+      } else {
+        console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}`);
+      }
+      if (result.events && result.events.length > 0) {
+        console.log(`  ${BOLD}Events:${RESET}`);
+        for (const event of result.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}`);
+          }
+        }
+      }
+      console.log();
+    } finally {
+      clientHandle.destroy();
+    }
+  });
+}
+function formatEventValue(v) {
+  if (typeof v === "bigint")
+    return v.toString();
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number")
+    return v.toString();
+  if (typeof v === "boolean")
+    return v.toString();
+  if (v === null || v === undefined)
+    return "null";
+  return JSON.stringify(v, (_k, val) => typeof val === "bigint" ? val.toString() : val);
+}
+function parseCallArgs(meta, palletName, callName, args) {
+  const palletMeta = meta.unified.pallets.find((p) => p.name === palletName);
+  if (!palletMeta?.calls)
+    return;
+  const callsEntry = meta.lookup(palletMeta.calls.type);
+  if (callsEntry.type !== "enum")
+    return;
+  const variant = callsEntry.value[callName];
+  if (!variant)
+    return;
+  if (variant.type === "void") {
+    if (args.length > 0) {
+      throw new Error(`${palletName}.${callName} takes no arguments, but ${args.length} provided.`);
+    }
+    return;
+  }
+  if (variant.type === "struct") {
+    return parseStructArgs(meta.lookup, variant.value, args, `${palletName}.${callName}`);
+  }
+  if (variant.type === "lookupEntry") {
+    const inner = variant.value;
+    if (inner.type === "struct") {
+      return parseStructArgs(meta.lookup, inner.value, args, `${palletName}.${callName}`);
+    }
+    if (inner.type === "void")
+      return;
+    if (args.length !== 1) {
+      throw new Error(`${palletName}.${callName} takes 1 argument (${describeType(meta.lookup, inner.id)}), but ${args.length} provided.`);
+    }
+    return parseTypedArg(meta.lookup, inner, args[0]);
+  }
+  if (variant.type === "tuple") {
+    const entries = variant.value;
+    if (args.length !== entries.length) {
+      throw new Error(`${palletName}.${callName} takes ${entries.length} arguments, but ${args.length} provided.`);
+    }
+    return entries.map((entry, i) => parseTypedArg(meta.lookup, entry, args[i]));
+  }
+  return args.length === 0 ? undefined : args.map(parseValue);
+}
+function parseStructArgs(lookup, fields, args, callLabel) {
+  const fieldNames = Object.keys(fields);
+  if (args.length !== fieldNames.length) {
+    const expected = fieldNames.map((name) => `${name}: ${describeType(lookup, fields[name].id)}`).join(", ");
+    throw new Error(`${callLabel} takes ${fieldNames.length} argument(s): ${expected}
+` + `  Got ${args.length} argument(s).`);
+  }
+  const result = {};
+  for (let i = 0;i < fieldNames.length; i++) {
+    const name = fieldNames[i];
+    const entry = fields[name];
+    result[name] = parseTypedArg(lookup, entry, args[i]);
+  }
+  return result;
+}
+function parseTypedArg(lookup, entry, arg) {
+  switch (entry.type) {
+    case "primitive":
+      return parsePrimitive(entry.value, arg);
+    case "compact":
+      return entry.isBig ? BigInt(arg) : parseInt(arg, 10);
+    case "AccountId32":
+    case "AccountId20":
+      return arg;
+    case "option": {
+      if (arg === "null" || arg === "undefined" || arg === "none") {
+        return;
+      }
+      return parseTypedArg(lookup, entry.value, arg);
+    }
+    case "enum": {
+      if (arg.startsWith("{")) {
+        try {
+          return JSON.parse(arg);
+        } catch {}
+      }
+      const variants = Object.keys(entry.value);
+      const matched = variants.find((v) => v.toLowerCase() === arg.toLowerCase());
+      if (matched) {
+        const variant = entry.value[matched];
+        if (variant.type === "void") {
+          return { type: matched };
+        }
+      }
+      return parseValue(arg);
+    }
+    case "sequence":
+    case "array":
+      if (arg.startsWith("[")) {
+        try {
+          return JSON.parse(arg);
+        } catch {}
+      }
+      if (/^0x[0-9a-fA-F]*$/.test(arg))
+        return arg;
+      return parseValue(arg);
+    case "struct":
+      if (arg.startsWith("{")) {
+        try {
+          return JSON.parse(arg);
+        } catch {}
+      }
+      return parseValue(arg);
+    case "tuple":
+      if (arg.startsWith("[")) {
+        try {
+          return JSON.parse(arg);
+        } catch {}
+      }
+      return parseValue(arg);
+    default:
+      return parseValue(arg);
+  }
+}
+function parsePrimitive(prim, arg) {
+  switch (prim) {
+    case "bool":
+      return arg === "true";
+    case "char":
+    case "str":
+      return arg;
+    case "u8":
+    case "u16":
+    case "u32":
+    case "i8":
+    case "i16":
+    case "i32":
+      return parseInt(arg, 10);
+    case "u64":
+    case "u128":
+    case "u256":
+    case "i64":
+    case "i128":
+    case "i256":
+      return BigInt(arg);
+    default:
+      return parseValue(arg);
+  }
+}
+
 // src/utils/errors.ts
 class CliError2 extends Error {
   constructor(message) {
@@ -743,8 +1307,10 @@ registerChainCommands(cli);
 registerInspectCommand(cli);
 registerQueryCommand(cli);
 registerConstCommand(cli);
+registerAccountCommands(cli);
+registerTxCommand(cli);
 cli.help();
-cli.version("0.1.2");
+cli.version("0.2.0");
 function handleError(err) {
   if (err instanceof CliError2) {
     console.error(`Error: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polkadot-cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI tool for querying Polkadot-ecosystem on-chain state",
   "type": "module",
   "bin": {
@@ -32,11 +32,13 @@
     "url": "git+https://github.com/peetzweg/polkadot-cli.git"
   },
   "dependencies": {
-    "cac": "^6.7.14",
-    "polkadot-api": "^1.23.3",
     "@polkadot-api/metadata-builders": "^0.13.9",
     "@polkadot-api/substrate-bindings": "^0.17.0",
-    "@polkadot-api/view-builder": "^0.4.17"
+    "@polkadot-api/view-builder": "^0.4.17",
+    "@polkadot-labs/hdkd": "^0.0.26",
+    "@polkadot-labs/hdkd-helpers": "^0.0.27",
+    "cac": "^6.7.14",
+    "polkadot-api": "^1.23.3"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.4",