polkadot-cli 0.4.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # polkadot-cli
 
-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.
+A command-line tool for interacting with Polkadot-ecosystem chains. Manage chains and accounts, query storage, look up constants, inspect metadata, submit extrinsics, and compute hashes — all from your terminal.
 
 Ships with Polkadot as the default chain. Add any Substrate-based chain by pointing to its RPC endpoint.
 
@@ -14,6 +14,48 @@ This installs the `dot` command globally.
 
 ## Usage
 
+### Manage chains
+
+```bash
+# Add a chain
+dot chain add kusama --rpc wss://kusama-rpc.polkadot.io
+dot chain add westend --light-client
+
+# List configured chains
+dot chain list
+
+# Re-fetch metadata after a runtime upgrade
+dot chain update          # updates default chain
+dot chain update kusama   # updates a specific chain
+
+# Set default chain
+dot chain default kusama
+
+# Remove a chain
+dot chain remove westend
+```
+
+### 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
+```
+
 ### Query storage
 
 ```bash
@@ -52,30 +94,9 @@ 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.
+Build, sign, and submit transactions. Pass a `Pallet.Call` with arguments, or a raw SCALE-encoded call hex (e.g. from a multisig proposal or governance). Both forms display a decoded human-readable representation of the call.
 
 ```bash
 # Simple remark
@@ -87,30 +108,74 @@ dot tx Balances.transferKeepAlive 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694
 # Estimate fees without submitting
 dot tx Balances.transferKeepAlive 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty 1000000000000 --from alice --dry-run
 
+# Submit a raw SCALE-encoded call (e.g. from a multisig proposal or another tool)
+dot tx 0x0503008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48 --from alice
+
 # 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
+#### Encode call data
+
+Encode a call to hex without signing or submitting. Useful for preparing calls to pass to `Sudo.sudo`, multisig proposals, or governance. Works offline from cached metadata and does not require `--from`.
 
 ```bash
-# Add a chain
-dot chain add kusama --rpc wss://kusama-rpc.polkadot.io
-dot chain add westend --light-client
+# Encode a remark call
+dot tx System.remark 0xdeadbeef --encode
 
-# List configured chains
-dot chain list
+# Encode a transfer (use the hex output in a batch or sudo call)
+dot tx Balances.transfer_keep_alive 5FHneW46... 1000000000000 --encode
 
-# Re-fetch metadata after a runtime upgrade
-dot chain update          # updates default chain
-dot chain update kusama   # updates a specific chain
+# Use encoded output with Sudo.sudo
+dot tx Sudo.sudo $(dot tx System.remark 0xcafe --encode) --from alice
+```
 
-# Set default chain
-dot chain default kusama
+Both dry-run and submission display the encoded call hex and a decoded human-readable form:
 
-# Remove a chain
-dot chain remove westend
 ```
+  Call:   0x0001076465616462656566
+  Decode: System.remark(remark: 0xdeadbeef)
+  Tx:     0xabc123...
+  Block:  #12345678 (0xdef...)
+  Status: ok
+```
+
+#### Custom signed extensions
+
+Chains with non-standard signed extensions (e.g. `people-preview`) are auto-handled:
+
+- `void` → empty bytes
+- `Option<T>` → `None`
+- enum with `Disabled` variant → `Disabled`
+
+For manual override, use `--ext` with a JSON object:
+
+```bash
+dot tx System.remark 0xdeadbeef --from alice --ext '{"MyExtension":{"value":"..."}}'
+```
+
+### Compute hashes
+
+Compute cryptographic hashes commonly used in Substrate. Supports BLAKE2b-256, BLAKE2b-128, Keccak-256, and SHA-256.
+
+```bash
+# Hash hex-encoded data
+dot hash blake2b256 0xdeadbeef
+
+# Hash plain text (UTF-8 encoded)
+dot hash sha256 hello
+
+# Hash file contents
+dot hash keccak256 --file ./data.bin
+
+# Read from stdin
+echo -n "hello" | dot hash sha256 --stdin
+
+# JSON output
+dot hash blake2b256 0xdeadbeef --output json
+```
+
+Run `dot hash` with no arguments to see all available algorithms.
 
 ### Global options
 
@@ -122,6 +187,21 @@ dot chain remove westend
 | `--output json` | Raw JSON output (default: pretty) |
 | `--limit <n>` | Max entries for map queries (0 = unlimited, default: 100) |
 
+## How it compares
+
+| | polkadot-cli | @polkadot/api-cli | subxt-cli | Pop CLI |
+|---|---|---|---|---|
+| **Query storage** | SS58 keys, map iteration | yes (full `--ws` URL required) | yes (keys as SCALE tuples, no SS58) | — |
+| **Read constants** | yes | yes | yes | — |
+| **Submit extrinsics** | yes, with dry-run | yes (via `--seed`) | — | ink! contract calls only |
+| **Inspect metadata** | yes | — | yes (excellent browser) | — |
+| **Chain presets** | built-in aliases (`--chain kusama`) | — (manual `--ws` every call) | — | parachain templates |
+| **Tx tracking + explorer links** | spinner progress, block + explorer link | basic events | — | — |
+
+polkadot-cli aims to be the single tool for day-to-day chain interaction: storage reads, constant lookups, transaction submission, and metadata browsing with a polished terminal UX. @polkadot/api-cli covers similar ground but is in maintenance mode and requires verbose flags. subxt-cli has an excellent metadata explorer but cannot sign or submit transactions. Pop CLI targets a different workflow — scaffolding parachains and deploying ink! contracts rather than end-user chain queries.
+
+Outside Polkadot, the closest comparable in terms of interactive UX is [near-cli-rs](https://github.com/near/near-cli-rs) (NEAR).
+
 ## Configuration
 
 Config and metadata caches live in `~/.polkadot/`:

package/dist/cli.mjs

@@ -1,21 +1,5 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
@@ -388,6 +372,38 @@ function printDocs(docs) {
     console.log(`  ${DIM}${text}${RESET}`);
   }
 }
+var CHECK_MARK = "✓";
+var SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class Spinner {
+  timer = null;
+  frame = 0;
+  start(msg) {
+    this.stop();
+    if (!isTTY) {
+      console.log(msg);
+      return;
+    }
+    process.stdout.write(`${SPINNER_FRAMES[0]} ${msg}`);
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+      process.stdout.write(`\r\x1B[K${SPINNER_FRAMES[this.frame]} ${msg}`);
+    }, 80);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+      this.frame = 0;
+      if (isTTY)
+        process.stdout.write("\r\x1B[K");
+    }
+  }
+  succeed(msg) {
+    this.stop();
+    console.log(`${GREEN}${CHECK_MARK}${RESET} ${msg}`);
+  }
+}
 
 // src/commands/chain.ts
 var CHAIN_HELP = `
@@ -1069,28 +1085,61 @@ async function accountRemove(name) {
 // src/commands/tx.ts
 import { Binary } from "polkadot-api";
 import { getViewBuilder } from "@polkadot-api/view-builder";
+
+// src/core/explorers.ts
+var pjsAppsLink = (rpc, hash) => `https://polkadot.js.org/apps/?rpc=${encodeURIComponent(rpc)}#/explorer/query/${hash}`;
+var papiLink = (rpc, hash) => `https://dev.papi.how/explorer/${hash}#networkId=custom&endpoint=${encodeURIComponent(rpc)}`;
+
+// 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").option("--ext <json>", `Custom signed extension values as JSON, e.g. '{"ExtName":{"value":...}}'`).action(async (target, args, opts) => {
-    if (!target || !opts.from) {
-      console.log("Usage: dot tx <Pallet.Call|0xCallHex> [...args] --from <account> [--dry-run]");
+  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").option("--encode", "Encode call to hex without signing or submitting").option("--ext <json>", `Custom signed extension values as JSON, e.g. '{"ExtName":{"value":...}}'`).action(async (target, args, opts) => {
+    if (!target) {
+      console.log("Usage: dot tx <Pallet.Call|0xCallHex> [...args] --from <account> [--dry-run] [--encode]");
       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");
       console.log("  $ dot tx 0x0001076465616462656566 --from alice");
+      console.log("  $ dot tx Assets.force_create 4 owner true 10 --encode --chain people");
       return;
     }
+    if (!opts.from && !opts.encode) {
+      throw new Error("--from is required (or use --encode to output hex without signing)");
+    }
+    if (opts.encode && opts.dryRun) {
+      throw new Error("--encode and --dry-run are mutually exclusive");
+    }
     const isRawCall = /^0x[0-9a-fA-F]+$/.test(target);
+    if (opts.encode && isRawCall) {
+      throw new Error("--encode cannot be used with raw call hex (already encoded)");
+    }
     const config = await loadConfig();
     const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
-    const signer = await resolveAccountSigner(opts.from);
-    const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+    const signer = opts.encode ? undefined : await resolveAccountSigner(opts.from);
+    let clientHandle;
+    if (!opts.encode) {
+      clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+    }
     try {
-      const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const userExtOverrides = parseExtOption(opts.ext);
-      const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
-      const txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
-      const unsafeApi = clientHandle.client.getUnsafeApi();
+      let meta;
+      if (clientHandle) {
+        meta = await getOrFetchMetadata(chainName, clientHandle);
+      } else {
+        try {
+          meta = await getOrFetchMetadata(chainName);
+        } catch {
+          clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
+          meta = await getOrFetchMetadata(chainName, clientHandle);
+        }
+      }
+      let unsafeApi;
+      let txOptions;
+      if (!opts.encode) {
+        const userExtOverrides = parseExtOption(opts.ext);
+        const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
+        txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
+        unsafeApi = clientHandle.client.getUnsafeApi();
+      }
       let tx;
       let callHex;
       if (isRawCall) {
@@ -1114,6 +1163,17 @@ function registerTxCommand(cli) {
           throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
         }
         const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
+        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
+          ]);
+          console.log(Binary.fromBytes(fullCall).asHex());
+          return;
+        }
         tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
         const encodedCall = await tx.getEncodedData();
         callHex = encodedCall.asHex();
@@ -1133,20 +1193,17 @@ function registerTxCommand(cli) {
         }
         return;
       }
-      console.log("Signing and submitting...");
-      const result = await tx.signAndSubmit(signer, txOptions);
+      const result = await watchTransaction(tx.signSubmitAndWatch(signer, txOptions));
       console.log();
       console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
       console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
       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}Block:${RESET}  #${result.block.number} (${result.block.hash})`);
+      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) : ""}`);
-      } else {
-        console.log(`  ${BOLD}Status:${RESET} ${GREEN}ok${RESET}`);
       }
       if (result.events && result.events.length > 0) {
         console.log(`  ${BOLD}Events:${RESET}`);
@@ -1161,9 +1218,16 @@ function registerTxCommand(cli) {
           }
         }
       }
+      const rpcUrl = opts.rpc ?? chainConfig.rpc;
+      if (rpcUrl) {
+        const blockHash = result.block.hash;
+        console.log(`  ${BOLD}Explorer:${RESET}`);
+        console.log(`    ${DIM}PolkadotJS${RESET}  ${pjsAppsLink(rpcUrl, blockHash)}`);
+        console.log(`    ${DIM}PAPI${RESET}        ${papiLink(rpcUrl, blockHash)}`);
+      }
       console.log();
     } finally {
-      clientHandle.destroy();
+      clientHandle?.destroy();
     }
   });
 }
@@ -1286,33 +1350,33 @@ function parseCallArgs(meta, palletName, callName, args) {
     return;
   }
   if (variant.type === "struct") {
-    return parseStructArgs(meta.lookup, variant.value, args, `${palletName}.${callName}`);
+    return parseStructArgs(meta, 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}`);
+      return parseStructArgs(meta, 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]);
+    return parseTypedArg(meta, 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 entries.map((entry, i) => parseTypedArg(meta, entry, args[i]));
   }
   return args.length === 0 ? undefined : args.map(parseValue);
 }
-function parseStructArgs(lookup, fields, args, callLabel) {
+function parseStructArgs(meta, 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(", ");
+    const expected = fieldNames.map((name) => `${name}: ${describeType(meta.lookup, fields[name].id)}`).join(", ");
     throw new Error(`${callLabel} takes ${fieldNames.length} argument(s): ${expected}
 ` + `  Got ${args.length} argument(s).`);
   }
@@ -1320,11 +1384,78 @@ function parseStructArgs(lookup, fields, args, callLabel) {
   for (let i = 0;i < fieldNames.length; i++) {
     const name = fieldNames[i];
     const entry = fields[name];
-    result[name] = parseTypedArg(lookup, entry, args[i]);
+    result[name] = parseTypedArg(meta, entry, args[i]);
   }
   return result;
 }
-function parseTypedArg(lookup, entry, arg) {
+function normalizeValue(lookup, entry, value) {
+  let resolved = entry;
+  while (resolved.type === "lookupEntry") {
+    resolved = resolved.value;
+  }
+  switch (resolved.type) {
+    case "enum": {
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && "type" in value) {
+        const enumValue = value;
+        const variant = resolved.value[enumValue.type];
+        if (variant) {
+          let innerEntry = variant;
+          while (innerEntry.type === "lookupEntry") {
+            innerEntry = innerEntry.value;
+          }
+          let normalizedInner = enumValue.value;
+          if (innerEntry.type !== "array" && innerEntry.type !== "sequence" && innerEntry.type !== "void" && Array.isArray(normalizedInner) && normalizedInner.length === 1) {
+            normalizedInner = normalizedInner[0];
+          }
+          if (normalizedInner !== undefined && innerEntry.type !== "void") {
+            normalizedInner = normalizeValue(lookup, innerEntry, normalizedInner);
+          }
+          return { type: enumValue.type, value: normalizedInner };
+        }
+      }
+      return value;
+    }
+    case "struct": {
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        const fields = resolved.value;
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          if (key in fields) {
+            result[key] = normalizeValue(lookup, fields[key], val);
+          } else {
+            result[key] = val;
+          }
+        }
+        return result;
+      }
+      return value;
+    }
+    case "array":
+    case "sequence": {
+      if (Array.isArray(value)) {
+        const innerEntry = resolved.value;
+        return value.map((item) => normalizeValue(lookup, innerEntry, item));
+      }
+      return value;
+    }
+    case "tuple": {
+      if (Array.isArray(value)) {
+        const entries = resolved.value;
+        return value.map((item, i) => i < entries.length ? normalizeValue(lookup, entries[i], item) : item);
+      }
+      return value;
+    }
+    case "option": {
+      if (value !== null && value !== undefined) {
+        return normalizeValue(lookup, resolved.value, value);
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function parseTypedArg(meta, entry, arg) {
   switch (entry.type) {
     case "primitive":
       return parsePrimitive(entry.value, arg);
@@ -1337,12 +1468,16 @@ function parseTypedArg(lookup, entry, arg) {
       if (arg === "null" || arg === "undefined" || arg === "none") {
         return;
       }
-      return parseTypedArg(lookup, entry.value, arg);
+      return parseTypedArg(meta, entry.value, arg);
     }
     case "enum": {
+      if (/^0x[0-9a-fA-F]+$/.test(arg) && meta.lookup.call != null && entry.id === meta.lookup.call) {
+        const callCodec = meta.builder.buildDefinition(meta.lookup.call);
+        return callCodec.dec(Binary.fromHex(arg).asBytes());
+      }
       if (arg.startsWith("{")) {
         try {
-          return JSON.parse(arg);
+          return normalizeValue(meta.lookup, entry, JSON.parse(arg));
         } catch {}
       }
       const variants = Object.keys(entry.value);
@@ -1372,7 +1507,7 @@ function parseTypedArg(lookup, entry, arg) {
       }
       if (arg.startsWith("[")) {
         try {
-          return JSON.parse(arg);
+          return normalizeValue(meta.lookup, entry, JSON.parse(arg));
         } catch {}
       }
       if (/^0x[0-9a-fA-F]*$/.test(arg))
@@ -1382,14 +1517,14 @@ function parseTypedArg(lookup, entry, arg) {
     case "struct":
       if (arg.startsWith("{")) {
         try {
-          return JSON.parse(arg);
+          return normalizeValue(meta.lookup, entry, JSON.parse(arg));
         } catch {}
       }
       return parseValue(arg);
     case "tuple":
       if (arg.startsWith("[")) {
         try {
-          return JSON.parse(arg);
+          return normalizeValue(meta.lookup, entry, JSON.parse(arg));
         } catch {}
       }
       return parseValue(arg);
@@ -1489,6 +1624,170 @@ function autoDefaultForType(entry) {
   }
   return NO_DEFAULT;
 }
+function watchTransaction(observable) {
+  const spinner = new Spinner;
+  return new Promise((resolve, reject) => {
+    spinner.start("Signing...");
+    observable.subscribe({
+      next(event) {
+        switch (event.type) {
+          case "signed":
+            spinner.succeed("Signed");
+            console.log(`  ${BOLD}Tx:${RESET}     ${event.txHash}`);
+            spinner.start("Broadcasting...");
+            break;
+          case "broadcasted":
+            spinner.succeed("Broadcasted");
+            spinner.start("In best block...");
+            break;
+          case "txBestBlocksState":
+            if (event.found) {
+              spinner.succeed(`In best block #${event.block.number}`);
+              spinner.start("Finalizing...");
+            } else {
+              spinner.start("In best block...");
+            }
+            break;
+          case "finalized":
+            spinner.stop();
+            resolve(event);
+            break;
+        }
+      },
+      error(err) {
+        spinner.stop();
+        reject(err);
+      }
+    });
+  });
+}
+
+// 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 {
@@ -1497,6 +1796,8 @@ class CliError2 extends Error {
     this.name = "CliError";
   }
 }
+// package.json
+var version = "0.6.0";
 
 // src/cli.ts
 var cli = cac("dot");
@@ -1512,8 +1813,9 @@ registerQueryCommand(cli);
 registerConstCommand(cli);
 registerAccountCommands(cli);
 registerTxCommand(cli);
+registerHashCommand(cli);
 cli.help();
-cli.version("0.3.0");
+cli.version(version);
 function handleError(err) {
   if (err instanceof CliError2) {
     console.error(`Error: ${err.message}`);
@@ -1524,11 +1826,15 @@ function handleError(err) {
   }
   process.exit(1);
 }
-process.on("unhandledRejection", handleError);
 try {
-  cli.parse();
+  cli.parse(process.argv, { run: false });
   if (!cli.matchedCommandName && !cli.options.help && !cli.options.version) {
     cli.outputHelp();
+  } else {
+    const result = cli.runMatchedCommand();
+    if (result && typeof result.then === "function") {
+      result.then(() => process.exit(0), handleError);
+    }
   }
 } catch (err) {
   handleError(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polkadot-cli",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "CLI tool for querying Polkadot-ecosystem on-chain state",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
     "url": "git+https://github.com/peetzweg/polkadot-cli.git"
   },
   "dependencies": {
+    "@noble/hashes": "^2.0.1",
     "@polkadot-api/metadata-builders": "^0.13.9",
     "@polkadot-api/substrate-bindings": "^0.17.0",
     "@polkadot-api/view-builder": "^0.4.17",