polkadot-cli 0.5.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # polkadot-cli
 
-A command-line tool for interacting with Polkadot-ecosystem chains. Manage chains and accounts, query storage, look up constants, inspect metadata, 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.
 
@@ -115,6 +115,21 @@ dot tx 0x0503008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48
 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
 ```
 
+#### 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
+# Encode a remark call
+dot tx System.remark 0xdeadbeef --encode
+
+# Encode a transfer (use the hex output in a batch or sudo call)
+dot tx Balances.transfer_keep_alive 5FHneW46... 1000000000000 --encode
+
+# Use encoded output with Sudo.sudo
+dot tx Sudo.sudo $(dot tx System.remark 0xcafe --encode) --from alice
+```
+
 Both dry-run and submission display the encoded call hex and a decoded human-readable form:
 
 ```
@@ -139,6 +154,29 @@ For manual override, use `--ext` with a JSON object:
 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
 
 | Flag | Description |
@@ -149,6 +187,21 @@ dot tx System.remark 0xdeadbeef --from alice --ext '{"MyExtension":{"value":"...
 | `--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

@@ -1092,27 +1092,54 @@ var papiLink = (rpc, hash) => `https://dev.papi.how/explorer/${hash}#networkId=c
 
 // 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) {
@@ -1136,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();
@@ -1189,7 +1227,7 @@ function registerTxCommand(cli) {
       }
       console.log();
     } finally {
-      clientHandle.destroy();
+      clientHandle?.destroy();
     }
   });
 }
@@ -1312,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).`);
   }
@@ -1346,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);
@@ -1363,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);
@@ -1398,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))
@@ -1408,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);
@@ -1553,6 +1662,133 @@ 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) {
@@ -1561,7 +1797,7 @@ class CliError2 extends Error {
   }
 }
 // package.json
-var version = "0.5.0";
+var version = "0.6.0";
 
 // src/cli.ts
 var cli = cac("dot");
@@ -1577,6 +1813,7 @@ registerQueryCommand(cli);
 registerConstCommand(cli);
 registerAccountCommands(cli);
 registerTxCommand(cli);
+registerHashCommand(cli);
 cli.help();
 cli.version(version);
 function handleError(err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polkadot-cli",
-  "version": "0.5.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",