polkadot-cli 1.19.0 → 1.21.0

package/dist/cli.mjs

@@ -73,7 +73,9 @@ var init_errors = __esm(() => {
     /codec/i,
     /decod(e|ing)/i,
     /Lookup failed/i,
-    /metadata.*mismatch/i
+    /metadata.*mismatch/i,
+    /BadProof/,
+    /AncientBirthBlock/
   ];
   BLOCK_UNAVAILABLE_PATTERNS = [
     /is not pinned/i,
@@ -231,31 +233,84 @@ var init_types = __esm(() => {
   BUILTIN_CHAIN_NAMES = new Set(Object.keys(DEFAULT_CONFIG.chains));
 });
 
+// src/config/workspace.ts
+import { realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function findWorkspace(startDir, home = homedir()) {
+  const homePath = canonicalPath(home);
+  let dir = canonicalPath(startDir);
+  while (dir !== homePath) {
+    const candidate = join(dir, WORKSPACE_DIR_NAME);
+    if (isDirectory(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+  return null;
+}
+var WORKSPACE_DIR_NAME = ".polkadot";
+var init_workspace = () => {};
+
 // src/config/store.ts
 import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-function getConfigDir() {
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function resolveConfigDir(cwd = process.cwd()) {
   const override = process.env.DOT_HOME;
-  return override && override.length > 0 ? override : join(homedir(), ".polkadot");
+  if (override && override.length > 0)
+    return { path: override, source: "env" };
+  const workspace = findWorkspace(cwd);
+  if (workspace)
+    return { path: workspace, source: "workspace" };
+  return { path: join2(homedir2(), ".polkadot"), source: "global" };
+}
+function describeConfigDir(resolved = resolveConfigDir()) {
+  switch (resolved.source) {
+    case "env":
+      return `DOT_HOME ${resolved.path}`;
+    case "workspace":
+      return `workspace ${resolved.path}`;
+    case "global":
+      return `global config ${resolved.path}`;
+  }
+}
+function getConfigDir() {
+  return resolveConfigDir().path;
 }
 function getChainsDir() {
-  return join(getConfigDir(), "chains");
+  return join2(getConfigDir(), "chains");
 }
 function getChainDir(chainName) {
-  return join(getChainsDir(), chainName);
+  return join2(getChainsDir(), chainName);
 }
 function getMetadataPath(chainName) {
-  return join(getChainDir(chainName), "metadata.bin");
+  return join2(getChainDir(chainName), "metadata.bin");
 }
 function getMetadataFingerprintPath(chainName) {
-  return join(getChainDir(chainName), "metadata.fingerprint.json");
+  return join2(getChainDir(chainName), "metadata.fingerprint.json");
 }
 function getRpcMethodsPath(chainName) {
-  return join(getChainDir(chainName), "rpc-methods.json");
+  return join2(getChainDir(chainName), "rpc-methods.json");
 }
 function getConfigPath() {
-  return join(getConfigDir(), "config.json");
+  return join2(getConfigDir(), "config.json");
 }
 async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
@@ -360,20 +415,21 @@ function resolveChain(config, chainFlag) {
   }
   const name = findChainName(config, chainFlag);
   if (!name) {
-    throw new CliError(`Unknown chain "${chainFlag}". Available chains: ${available}`);
+    throw new CliError(`Unknown chain "${chainFlag}" in ${describeConfigDir()}. Available chains: ${available}`);
   }
   return { name, chain: config.chains[name] };
 }
 var init_store = __esm(() => {
   init_errors();
   init_types();
+  init_workspace();
 });
 
 // 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";
+import { join as join3 } from "node:path";
 function getAccountsPath() {
-  return join2(getConfigDir(), "accounts.json");
+  return join3(getConfigDir(), "accounts.json");
 }
 async function ensureDir2(dir) {
   await mkdir2(dir, { recursive: true });
@@ -461,6 +517,7 @@ function suggestMessage(kind, input, candidates) {
 }
 
 // src/core/accounts.ts
+import { hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
 import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import {
   DEV_PHRASE,
@@ -471,7 +528,7 @@ import {
   ss58Decode,
   validateMnemonic
 } from "@polkadot-labs/hdkd-helpers";
-import { HDKD, secretFromSeed } from "@scure/sr25519";
+import { getPublicKey, HDKD, secretFromSeed, sign } from "@scure/sr25519";
 import { getPolkadotSigner } from "polkadot-api/signer";
 function isDevAccount(name) {
   return DEV_NAMES.includes(name.toLowerCase());
@@ -486,18 +543,54 @@ function deriveFromMnemonic(mnemonic, path) {
   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);
+  const derive = sr25519CreateDerive(hexToBytes(hexSeed));
   return derive(path);
 }
 function getDevKeypair(name) {
   const path = devDerivationPath(name);
   return deriveFromMnemonic(DEV_PHRASE, path);
 }
+function hexToBytes(hex) {
+  return nobleHexToBytes(hex.startsWith("0x") ? hex.slice(2) : hex);
+}
+function isExpandedSecret(secret) {
+  return EXPANDED_SECRET_RE.test(secret);
+}
+function isHexSeed(secret) {
+  return HEX_SEED_RE.test(secret);
+}
+function secretKind(secret) {
+  if (isExpandedSecret(secret))
+    return "expanded";
+  if (isHexSeed(secret))
+    return "seed";
+  return "mnemonic";
+}
+function assertNoPathForExpandedSecret(derivationPath) {
+  if (derivationPath) {
+    throw new Error("Stored account has a 64-byte expanded secret with a derivation path, which cannot be applied. An expanded secret cannot be HD-derived; remove the derivationPath from accounts.json.");
+  }
+}
+function keypairFromExpandedSecret(secret) {
+  return {
+    publicKey: getPublicKey(secret),
+    sign: (msg) => sign(secret, msg)
+  };
+}
+function keypairFromSecret(secret, derivationPath = "") {
+  if (isExpandedSecret(secret)) {
+    assertNoPathForExpandedSecret(derivationPath);
+    return keypairFromExpandedSecret(hexToBytes(secret));
+  }
+  return isHexSeed(secret) ? deriveFromHexSeed(secret, derivationPath) : deriveFromMnemonic(secret, derivationPath);
+}
+function expandedSecretFromStored(secret, derivationPath = "") {
+  if (isExpandedSecret(secret)) {
+    assertNoPathForExpandedSecret(derivationPath);
+    return hexToBytes(secret);
+  }
+  return deriveExpandedSecret(miniSecretFromSecret(secret), derivationPath);
+}
 function parseDerivations(path) {
   const out = [];
   for (const [, type, code] of path.matchAll(DERIVATION_RE)) {
@@ -528,17 +621,11 @@ function deriveExpandedSecret(miniSecret, path) {
   return parseDerivations(path).reduce((sk, [type, code]) => type === "hard" ? HDKD.secretHard(sk, createChainCode(code)) : HDKD.secretSoft(sk, createChainCode(code)), secretFromSeed(miniSecret));
 }
 function miniSecretFromSecret(secret) {
-  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(secret);
-  if (isHexSeed) {
-    const clean = secret.slice(2);
-    const bytes = new Uint8Array(32);
-    for (let i = 0;i < clean.length; i += 2) {
-      bytes[i / 2] = parseInt(clean.substring(i, i + 2), 16);
-    }
-    return bytes;
+  if (isHexSeed(secret)) {
+    return hexToBytes(secret);
   }
   if (!validateMnemonic(secret)) {
-    throw new Error("Invalid secret. Expected a 0x-prefixed 32-byte hex seed or a valid BIP39 mnemonic.");
+    throw new Error("Invalid secret. Expected a BIP39 mnemonic or a 0x-prefixed 32-byte hex seed.");
   }
   return entropyToMiniSecret(mnemonicToEntropy(secret));
 }
@@ -555,13 +642,19 @@ function createNewAccount(path = "") {
   return { mnemonic, publicKey: keypair.publicKey };
 }
 function importAccount(secret, path = "") {
-  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(secret);
-  if (isHexSeed) {
+  if (isExpandedSecret(secret)) {
+    if (path) {
+      throw new Error("Derivation paths are not supported for raw private key (64-byte expanded secret) import. An expanded secret cannot be HD-derived; omit --path.");
+    }
+    const keypair2 = keypairFromExpandedSecret(hexToBytes(secret));
+    return { publicKey: keypair2.publicKey };
+  }
+  if (isHexSeed(secret)) {
     const keypair2 = deriveFromHexSeed(secret, path);
     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.");
+    throw new Error("Invalid secret. Expected a BIP39 mnemonic, a 0x-prefixed 32-byte hex seed, or a 0x-prefixed 64-byte sr25519 expanded secret.");
   }
   const keypair = deriveFromMnemonic(secret, path);
   return { publicKey: keypair.publicKey };
@@ -608,6 +701,16 @@ function tryDerivePublicKey(envVarName, path = "") {
     return null;
   }
 }
+function unknownAccountError(name, accountsFile) {
+  const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
+  const suggestions = findClosest(name, available);
+  const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+  const list = available.map((a) => `
+    - ${a}`).join("");
+  return new Error(`Unknown account "${name}" in ${describeConfigDir()}.${hint}
+  Available accounts:${list}`);
+}
 async function resolveAccountKeypair(name) {
   if (isDevAccount(name)) {
     return getDevKeypair(name);
@@ -615,21 +718,12 @@ async function resolveAccountKeypair(name) {
   const accountsFile = await loadAccounts();
   const account = findAccount(accountsFile, name);
   if (!account) {
-    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
-    const suggestions = findClosest(name, available);
-    const hint = suggestions.length > 0 ? `
-  Did you mean: ${suggestions.join(", ")}?` : "";
-    const list = available.map((a) => `
-    - ${a}`).join("");
-    throw new Error(`Unknown account "${name}".${hint}
-  Available accounts:${list}`);
+    throw unknownAccountError(name, accountsFile);
   }
   if (account.secret === undefined) {
     throw new Error(`Account "${name}" is watch-only (no secret). Cannot sign. Import with --secret or --env.`);
   }
-  const secret = resolveSecret(account.secret);
-  const isHexSeed = /^0x[0-9a-fA-F]{64}$/.test(secret);
-  return isHexSeed ? deriveFromHexSeed(secret, account.derivationPath) : deriveFromMnemonic(secret, account.derivationPath);
+  return keypairFromSecret(resolveSecret(account.secret), account.derivationPath);
 }
 async function resolveAccountSigner(name) {
   const keypair = await resolveAccountKeypair(name);
@@ -637,34 +731,29 @@ async function resolveAccountSigner(name) {
 }
 async function resolveAccountExpandedSecret(name) {
   if (isDevAccount(name)) {
-    const miniSecret2 = entropyToMiniSecret(mnemonicToEntropy(DEV_PHRASE));
-    return deriveExpandedSecret(miniSecret2, devDerivationPath(name));
+    const miniSecret = entropyToMiniSecret(mnemonicToEntropy(DEV_PHRASE));
+    return deriveExpandedSecret(miniSecret, devDerivationPath(name));
   }
   const accountsFile = await loadAccounts();
   const account = findAccount(accountsFile, name);
   if (!account) {
-    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
-    const suggestions = findClosest(name, available);
-    const hint = suggestions.length > 0 ? `
-  Did you mean: ${suggestions.join(", ")}?` : "";
-    const list = available.map((a) => `
-    - ${a}`).join("");
-    throw new Error(`Unknown account "${name}".${hint}
-  Available accounts:${list}`);
+    throw unknownAccountError(name, accountsFile);
   }
   if (account.secret === undefined) {
     throw new Error(`Account "${name}" is watch-only (no secret). Cannot derive private key. Import with --secret or --env.`);
   }
-  const miniSecret = miniSecretFromSecret(resolveSecret(account.secret));
-  return deriveExpandedSecret(miniSecret, account.derivationPath);
+  return expandedSecretFromStored(resolveSecret(account.secret), account.derivationPath);
 }
 function bytesToHex(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-var DEV_NAMES, DERIVATION_RE;
+var DEV_NAMES, EXPANDED_SECRET_RE, HEX_SEED_RE, DERIVATION_RE;
 var init_accounts = __esm(() => {
   init_accounts_store();
+  init_store();
   DEV_NAMES = ["alice", "bob", "charlie", "dave", "eve", "ferdie"];
+  EXPANDED_SECRET_RE = /^0x[0-9a-fA-F]{128}$/;
+  HEX_SEED_RE = /^0x[0-9a-fA-F]{64}$/;
   DERIVATION_RE = /(\/{1,2})([^/]+)/g;
 });
 
@@ -723,8 +812,8 @@ function isJsonOutput(opts) {
   return opts.json === true || opts.output === "json";
 }
 function writeStdout(text) {
-  return new Promise((resolve) => {
-    process.stdout.write(text, () => resolve());
+  return new Promise((resolve2) => {
+    process.stdout.write(text, () => resolve2());
   });
 }
 function printJsonLine(data) {
@@ -828,24 +917,130 @@ var init_output = __esm(() => {
   SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 });
 
-// src/core/bandersnatch.ts
-var exports_bandersnatch = {};
-__export(exports_bandersnatch, {
-  deriveBandersnatchMember: () => deriveBandersnatchMember
+// src/features/verifiable/lib.ts
+var exports_lib = {};
+__export(exports_lib, {
+  verifyRingProof: () => verifyRingProof,
+  verifyBandersnatchSig: () => verifyBandersnatchSig,
+  ringRoot: () => ringRoot,
+  ringProve: () => ringProve,
+  resolveEntropyKey: () => resolveEntropyKey,
+  isRingExponent: () => isRingExponent,
+  encodeMembers: () => encodeMembers,
+  encodeContext: () => encodeContext,
+  deriveMemberKey: () => deriveMemberKey,
+  deriveMemberEntropy: () => deriveMemberEntropy,
+  deriveBandersnatchMember: () => deriveBandersnatchMember,
+  deriveAlias: () => deriveAlias,
+  compactEncode: () => compactEncode,
+  bandersnatchSign: () => bandersnatchSign,
+  DEFAULT_RING_EXPONENT: () => DEFAULT_RING_EXPONENT
 });
 import { blake2b } from "@noble/hashes/blake2.js";
+import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
+import { compact } from "@polkadot-api/substrate-bindings";
 import { mnemonicToEntropy as mnemonicToEntropy2 } from "@polkadot-labs/hdkd-helpers";
-import { member_from_entropy } from "verifiablejs/nodejs";
-function deriveBandersnatchMember(mnemonic, context) {
+import {
+  alias_in_context,
+  member_from_entropy,
+  members_root,
+  one_shot,
+  sign as sign2,
+  validate,
+  validate_with_commitment,
+  verify_signature
+} from "verifiablejs/nodejs";
+function isRingExponent(n) {
+  return RING_EXPONENTS.includes(n);
+}
+function textOrHexBytes(value, label) {
+  if (value.startsWith("0x")) {
+    const hex = value.slice(2);
+    if (hex.length % 2 !== 0) {
+      throw new Error(`Invalid hex ${label}: odd number of characters`);
+    }
+    return hexToBytes3(hex);
+  }
+  return new TextEncoder().encode(value);
+}
+function resolveEntropyKey(value) {
+  if (value === undefined || value === "")
+    return;
+  return textOrHexBytes(value, "entropy-key");
+}
+function deriveMemberEntropy(mnemonic, entropyKey) {
   const entropy = mnemonicToEntropy2(mnemonic);
   const opts = { dkLen: 32 };
-  if (context) {
-    opts.key = new TextEncoder().encode(context);
+  if (entropyKey !== undefined && entropyKey.length > 0) {
+    opts.key = entropyKey;
+  }
+  return blake2b(entropy, opts);
+}
+function deriveMemberKey(entropy) {
+  return member_from_entropy(entropy);
+}
+function deriveBandersnatchMember(mnemonic, entropyKey) {
+  return deriveMemberKey(deriveMemberEntropy(mnemonic, resolveEntropyKey(entropyKey)));
+}
+function deriveAlias(entropy, context) {
+  return alias_in_context(entropy, context);
+}
+function bandersnatchSign(entropy, message) {
+  return sign2(entropy, message);
+}
+function verifyBandersnatchSig(signature, message, member) {
+  return verify_signature(signature, message, member);
+}
+function ringProve(ringExp, entropy, members, context, message) {
+  const result = one_shot(ringExp, entropy, members, context, message);
+  return { proof: result.proof, alias: result.alias };
+}
+function verifyRingProof(ringExp, proof, source, context, message) {
+  if (source.commitment !== undefined) {
+    return validate_with_commitment(ringExp, proof, source.commitment, context, message);
+  }
+  if (source.members !== undefined) {
+    return validate(ringExp, proof, source.members, context, message);
+  }
+  throw new Error("verifyRingProof requires either `members` or `commitment`");
+}
+function ringRoot(ringExp, members) {
+  return members_root(ringExp, members);
+}
+function compactEncode(n) {
+  if (!Number.isInteger(n) || n < 0)
+    throw new Error("compactEncode: non-negative integer required");
+  return compact.enc(n);
+}
+function encodeMembers(members) {
+  for (const m of members) {
+    if (m.length !== 32) {
+      throw new Error(`member key must be 32 bytes (got ${m.length})`);
+    }
+  }
+  const prefix = compactEncode(members.length);
+  const out = new Uint8Array(prefix.length + members.length * 32);
+  out.set(prefix, 0);
+  let offset = prefix.length;
+  for (const m of members) {
+    out.set(m, offset);
+    offset += 32;
+  }
+  return out;
+}
+function encodeContext(input) {
+  const bytes = textOrHexBytes(input, "context");
+  if (bytes.length > 32) {
+    throw new Error(`Context must be at most 32 bytes (got ${bytes.length})`);
   }
-  const hashed = blake2b(entropy, opts);
-  return member_from_entropy(hashed);
+  const out = new Uint8Array(32);
+  out.set(bytes, 0);
+  return out;
 }
-var init_bandersnatch = () => {};
+var RING_EXPONENTS, DEFAULT_RING_EXPONENT = 9;
+var init_lib = __esm(() => {
+  RING_EXPONENTS = [9, 10, 14];
+});
 
 // src/core/client.ts
 import { createClient } from "polkadot-api";
@@ -971,9 +1166,9 @@ function compactEntry(entry, color) {
   }
 }
 function expandEntry(entry, indent, width, color, prefix = 0) {
-  const compact = compactEntry(entry, color);
-  if (visualWidth(compact) + indent + prefix <= width)
-    return compact;
+  const compact2 = compactEntry(entry, color);
+  if (visualWidth(compact2) + indent + prefix <= width)
+    return compact2;
   switch (entry.type) {
     case "struct":
       return expandStruct(entry.value, indent, width, color);
@@ -1007,7 +1202,7 @@ ${closePadding}>`;
     case "lookupEntry":
       return expandEntry(entry.value, indent, width, color);
     default:
-      return compact;
+      return compact2;
   }
 }
 function expandStruct(fields, indent, width, color) {
@@ -1066,9 +1261,9 @@ ${closePadding}${close}`;
 }
 function prettyType(entry, opts = {}) {
   const { indent, prefix, width, color } = resolveOpts(opts);
-  const compact = compactEntry(entry, color);
-  if (visualWidth(compact) + indent + prefix <= width)
-    return compact;
+  const compact2 = compactEntry(entry, color);
+  if (visualWidth(compact2) + indent + prefix <= width)
+    return compact2;
   return expandEntry(entry, indent, width, color);
 }
 function prettyTypeById(lookup, typeId, opts = {}) {
@@ -1172,15 +1367,15 @@ function renderArgsFromFields(fields, opts) {
     case "void":
       return "()";
     case "named": {
-      const compact = `(${fields.fields.map(([k, v]) => `${paint(color, CYAN2, k)}: ${compactEntry(v, color)}`).join(", ")})`;
-      if (visualWidth(compact) + lead <= width)
-        return compact;
+      const compact2 = `(${fields.fields.map(([k, v]) => `${paint(color, CYAN2, k)}: ${compactEntry(v, color)}`).join(", ")})`;
+      if (visualWidth(compact2) + lead <= width)
+        return compact2;
       return renderFieldList(fields.fields, "(", ")", indent, width, color);
     }
     case "positional": {
-      const compact = `(${fields.types.map((t) => compactEntry(t, color)).join(", ")})`;
-      if (visualWidth(compact) + lead <= width)
-        return compact;
+      const compact2 = `(${fields.types.map((t) => compactEntry(t, color)).join(", ")})`;
+      if (visualWidth(compact2) + lead <= width)
+        return compact2;
       const innerIndent = indent + 2;
       const padding = " ".repeat(innerIndent);
       const closePadding = " ".repeat(indent);
@@ -1191,9 +1386,9 @@ ${lines.join(`,
 ${closePadding})`;
     }
     case "single": {
-      const compact = `(${compactEntry(fields.type, color)})`;
-      if (visualWidth(compact) + lead <= width)
-        return compact;
+      const compact2 = `(${compactEntry(fields.type, color)})`;
+      if (visualWidth(compact2) + lead <= width)
+        return compact2;
       const inner = expandEntry(fields.type, indent + 2, width, color);
       return `(
 ${" ".repeat(indent + 2)}${inner},
@@ -1264,7 +1459,7 @@ async function fetchMetadataFromChain(clientHandle, chainName) {
   let bytes;
   try {
     const hex = await withTimeout(client._request("state_call", ["Metadata_metadata_at_version", v15Arg]), chainName);
-    const raw = hexToBytes2(hex);
+    const raw = hexToBytes4(hex);
     const decoded = optionalOpaqueBytes.dec(raw);
     if (decoded !== undefined) {
       bytes = new Uint8Array(decoded);
@@ -1273,7 +1468,7 @@ async function fetchMetadataFromChain(clientHandle, chainName) {
   if (!bytes) {
     try {
       const hex = await withTimeout(client._request("state_getMetadata", []), chainName);
-      bytes = hexToBytes2(hex);
+      bytes = hexToBytes4(hex);
     } catch (err) {
       if (err instanceof ConnectionError)
         throw err;
@@ -1469,7 +1664,7 @@ function describeCallArgs(meta, palletName, callName) {
 function describeEventFields(meta, palletName, eventName) {
   return compactArgsString(getEventFields(meta, palletName, eventName));
 }
-function hexToBytes2(hex) {
+function hexToBytes4(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) {
@@ -3198,7 +3393,7 @@ var init_xxh64 = __esm(() => {
 import { blake2b as blake2b2 } from "@noble/hashes/blake2.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { keccak_256 as keccak_2562 } from "@noble/hashes/sha3.js";
-import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes5 } from "@noble/hashes/utils.js";
 function computeHash(algorithm, data) {
   const algo = ALGORITHMS[algorithm];
   if (!algo) {
@@ -3212,7 +3407,7 @@ function parseInputData(input) {
     if (hex.length % 2 !== 0) {
       throw new Error(`Invalid hex input: odd number of characters`);
     }
-    return hexToBytes3(hex);
+    return hexToBytes5(hex);
   }
   return new TextEncoder().encode(input);
 }
@@ -3267,6 +3462,349 @@ var init_hash = __esm(() => {
   };
 });
 
+// src/core/input.ts
+import { readFile as readFile5 } from "node:fs/promises";
+async function resolveDataInput(inline, opts, messages) {
+  const sources = [inline !== undefined, !!opts.file, !!opts.stdin].filter(Boolean).length;
+  if (sources > 1) {
+    throw new CliError(messages?.conflict ?? "Provide only one of: inline data, --file, or --stdin");
+  }
+  if (sources === 0) {
+    throw new CliError(messages?.missing ?? "No input provided. Pass data as argument, or use --file or --stdin");
+  }
+  if (opts.file) {
+    const buf = await readFile5(opts.file);
+    return new Uint8Array(buf);
+  }
+  if (opts.stdin) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    return new Uint8Array(Buffer.concat(chunks));
+  }
+  return parseInputData(inline);
+}
+var init_input = __esm(() => {
+  init_errors();
+  init_hash();
+});
+
+// src/platform/cli.ts
+function readRawOptionValue(name, argv = process.argv) {
+  const flag = `--${name}`;
+  const prefix = `${flag}=`;
+  let value;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--")
+      break;
+    if (arg === flag && i + 1 < argv.length)
+      value = argv[i + 1];
+    else if (arg.startsWith(prefix))
+      value = arg.slice(prefix.length);
+  }
+  return value;
+}
+
+// src/platform/index.ts
+var init_platform = __esm(() => {
+  init_accounts_store();
+  init_accounts();
+  init_hash();
+  init_input();
+  init_output();
+  init_errors();
+});
+
+// src/features/verifiable/commands.ts
+var exports_commands = {};
+__export(exports_commands, {
+  runVerifiable: () => runVerifiable
+});
+import { readFile as readFile8 } from "node:fs/promises";
+import { DEV_PHRASE as DEV_PHRASE2 } from "@polkadot-labs/hdkd-helpers";
+async function runVerifiable(action, rest, opts) {
+  switch (action) {
+    case "member":
+      return deriveMember(rest[0], opts);
+    case "alias":
+      return deriveAliasCmd(rest[0], opts);
+    case "sign":
+      return signCmd(rest[0], opts);
+    case "prove":
+      return proveCmd(rest[0], opts);
+    case "verify":
+      return verifyCmd(opts);
+    case "verify-sig":
+      return verifySigCmd(opts);
+    case "members":
+      return membersCmd(rest, opts);
+    default:
+      return deriveMember(action, opts);
+  }
+}
+function mnemonicFromStored(stored, account, accountsFile) {
+  if (!stored) {
+    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
+    const suggestions = findClosest(account, available);
+    const hint = suggestions.length > 0 ? `
+  Did you mean: ${suggestions.join(", ")}?` : "";
+    const list = available.map((a) => `
+    - ${a}`).join("");
+    throw new Error(`Unknown account "${account}".${hint}
+  Available accounts:${list}`);
+  }
+  if (isWatchOnly(stored)) {
+    throw new Error(`Account "${account}" is watch-only (no secret). Cannot derive Bandersnatch key.`);
+  }
+  const secret = resolveSecret(stored.secret);
+  if (isHexPublicKey(`0x${secret.replace(/^0x/, "")}`)) {
+    throw new Error(`Account "${account}" uses a hex seed. Bandersnatch derivation requires a BIP39 mnemonic.`);
+  }
+  return secret;
+}
+async function resolveMnemonic(account) {
+  if (isDevAccount(account)) {
+    return DEV_PHRASE2;
+  }
+  const accountsFile = await loadAccounts();
+  return mnemonicFromStored(findAccount(accountsFile, account), account, accountsFile);
+}
+async function resolveEntropy(account, entropyKey) {
+  const mnemonic = await resolveMnemonic(account);
+  return deriveMemberEntropy(mnemonic, resolveEntropyKey(entropyKey));
+}
+function requireAccount(account, action) {
+  if (!account) {
+    throw new CliError(`dot verifiable ${action} requires an account. See "dot verifiable".`);
+  }
+  return account;
+}
+function resolveMessage(opts) {
+  return resolveDataInput(opts.message, opts, {
+    conflict: "Provide only one of: --message, --file, or --stdin",
+    missing: "No message provided. Use --message, --file, or --stdin"
+  });
+}
+async function resolveBytesArg(value, name, allowFile = false) {
+  if (value.startsWith("0x")) {
+    return parseInputData(value);
+  }
+  if (allowFile) {
+    const buf = await readFile8(value);
+    const text = buf.toString("utf8").trim();
+    return text.startsWith("0x") ? parseInputData(text) : new Uint8Array(buf);
+  }
+  throw new CliError(`${name} must be 0x-prefixed hex`);
+}
+function resolveRingExponent(opts) {
+  if (opts.ringExponent === undefined)
+    return DEFAULT_RING_EXPONENT;
+  const n = Number(opts.ringExponent);
+  if (!isRingExponent(n)) {
+    throw new CliError(`Invalid --ring-exponent "${opts.ringExponent}". Supported: 9, 10, 14.`);
+  }
+  return n;
+}
+function requireOption(value, flag, action) {
+  if (value === undefined) {
+    throw new CliError(`dot verifiable ${action} requires ${flag}.`);
+  }
+  return value;
+}
+async function deriveMember(accountArg, opts) {
+  const account = requireAccount(accountArg, "member");
+  const usedDeprecatedContext = opts.entropyKey === undefined && opts.context !== undefined;
+  if (usedDeprecatedContext) {
+    if (opts.context.startsWith("0x")) {
+      throw new CliError(`"--context" on "dot verifiable" now means the 32-byte ring context, and hex ` + `entropy keys changed meaning in this release. Pass "--entropy-key ${opts.context}" explicitly.`);
+    }
+    process.stderr.write(`Warning: "--context" on "dot verifiable" now refers to the 32-byte ring context. ` + `For member-key derivation use "--entropy-key". Treating "--context ${opts.context}" ` + `as the entropy key for now.
+`);
+  }
+  const entropyKeyStr = opts.entropyKey ?? opts.context;
+  let mnemonic;
+  let accountsFile;
+  let stored;
+  if (isDevAccount(account)) {
+    mnemonic = DEV_PHRASE2;
+  } else {
+    accountsFile = await loadAccounts();
+    stored = findAccount(accountsFile, account);
+    mnemonic = mnemonicFromStored(stored, account, accountsFile);
+  }
+  const memberKeyHex = publicKeyToHex(deriveBandersnatchMember(mnemonic, entropyKeyStr));
+  if (stored && accountsFile) {
+    if (!stored.bandersnatch)
+      stored.bandersnatch = {};
+    const entryKey = entropyKeyStr ?? "";
+    if (stored.bandersnatch[entryKey] !== memberKeyHex) {
+      stored.bandersnatch[entryKey] = memberKeyHex;
+      await saveAccounts(accountsFile);
+    }
+  }
+  const fieldKey = usedDeprecatedContext ? "context" : "entropyKey";
+  if (isJsonOutput(opts)) {
+    const result = { account, memberKey: memberKeyHex };
+    if (entropyKeyStr)
+      result[fieldKey] = entropyKeyStr;
+    console.log(formatJson(result));
+  } else {
+    printHeading("Bandersnatch Member Key");
+    console.log(`  ${BOLD}Account:${RESET}    ${account}`);
+    if (entropyKeyStr) {
+      const line = usedDeprecatedContext ? `  ${BOLD}Context:${RESET}    ${entropyKeyStr}` : `  ${BOLD}Entropy Key:${RESET} ${entropyKeyStr}`;
+      console.log(line);
+    }
+    console.log(`  ${BOLD}Member Key:${RESET} ${memberKeyHex}`);
+    console.log();
+  }
+}
+async function deriveAliasCmd(accountArg, opts) {
+  const account = requireAccount(accountArg, "alias");
+  const contextStr = requireOption(opts.context, "--context", "alias");
+  const entropy = await resolveEntropy(account, opts.entropyKey);
+  const context = encodeContext(contextStr);
+  const aliasHex = toHex2(deriveAlias(entropy, context));
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ account, context: contextStr, alias: aliasHex }));
+  } else {
+    printHeading("Verifiable Alias");
+    console.log(`  ${BOLD}Account:${RESET} ${account}`);
+    console.log(`  ${BOLD}Context:${RESET} ${contextStr}`);
+    console.log(`  ${BOLD}Alias:${RESET}   ${aliasHex}`);
+    console.log();
+  }
+}
+async function signCmd(accountArg, opts) {
+  const account = requireAccount(accountArg, "sign");
+  const message = await resolveMessage(opts);
+  const entropy = await resolveEntropy(account, opts.entropyKey);
+  const signature = bandersnatchSign(entropy, message);
+  const member = deriveMemberKey(entropy);
+  const sigHex = toHex2(signature);
+  const result = {
+    type: "Bandersnatch",
+    account,
+    message: toHex2(message),
+    signature: sigHex,
+    member: toHex2(member),
+    enum: `Bandersnatch(${sigHex})`
+  };
+  if (isJsonOutput(opts)) {
+    console.log(formatJson(result));
+  } else {
+    console.log(`  ${BOLD}Type:${RESET}       ${result.type}`);
+    console.log(`  ${BOLD}Message:${RESET}    ${result.message}`);
+    console.log(`  ${BOLD}Signature:${RESET}  ${result.signature}`);
+    console.log(`  ${BOLD}Member:${RESET}     ${result.member}`);
+    console.log(`  ${BOLD}Enum:${RESET}       ${result.enum}`);
+  }
+}
+async function proveCmd(accountArg, opts) {
+  const account = requireAccount(accountArg, "prove");
+  const contextStr = requireOption(opts.context, "--context", "prove");
+  const membersArg = requireOption(opts.members, "--members", "prove");
+  const message = await resolveMessage(opts);
+  const ringExponent = resolveRingExponent(opts);
+  const entropy = await resolveEntropy(account, opts.entropyKey);
+  const context = encodeContext(contextStr);
+  const members = await resolveBytesArg(membersArg, "--members", true);
+  const { proof, alias } = ringProve(ringExponent, entropy, members, context, message);
+  const result = {
+    account,
+    context: contextStr,
+    ringExponent,
+    alias: toHex2(alias),
+    proof: toHex2(proof)
+  };
+  if (isJsonOutput(opts)) {
+    console.log(formatJson(result));
+  } else {
+    printHeading("Ring-VRF Proof");
+    console.log(`  ${BOLD}Account:${RESET}       ${account}`);
+    console.log(`  ${BOLD}Context:${RESET}       ${contextStr}`);
+    console.log(`  ${BOLD}Ring exponent:${RESET} ${ringExponent}`);
+    console.log(`  ${BOLD}Alias:${RESET}         ${result.alias}`);
+    console.log(`  ${BOLD}Proof:${RESET}         ${result.proof}`);
+    console.log();
+  }
+}
+async function verifyCmd(opts) {
+  const proofArg = requireOption(opts.proof, "--proof", "verify");
+  const contextStr = requireOption(opts.context, "--context", "verify");
+  if (!opts.members && !opts.root) {
+    throw new CliError("dot verifiable verify requires --members or --root.");
+  }
+  if (opts.members && opts.root) {
+    throw new CliError("Provide either --members or --root, not both.");
+  }
+  const message = await resolveMessage(opts);
+  const ringExponent = resolveRingExponent(opts);
+  const proof = await resolveBytesArg(proofArg, "--proof", true);
+  const context = encodeContext(contextStr);
+  const source = opts.root ? { commitment: await resolveBytesArg(opts.root, "--root", true) } : { members: await resolveBytesArg(opts.members, "--members", true) };
+  let aliasHex;
+  try {
+    aliasHex = toHex2(verifyRingProof(ringExponent, proof, source, context, message));
+  } catch (err) {
+    const exponentHint = opts.ringExponent === undefined ? ` (assumed ring exponent ${ringExponent} — pass --ring-exponent if the ring uses 10 or 14)` : "";
+    throw new CliError(`Ring-VRF proof is invalid: ${err instanceof Error ? err.message : String(err)}${exponentHint}`);
+  }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ valid: true, alias: aliasHex, ringExponent }));
+  } else {
+    printHeading("Ring-VRF Verification");
+    console.log(`  ${BOLD}Valid:${RESET} yes`);
+    console.log(`  ${BOLD}Alias:${RESET} ${aliasHex}`);
+    console.log();
+  }
+}
+async function verifySigCmd(opts) {
+  const sigArg = requireOption(opts.signature, "--signature", "verify-sig");
+  const memberArg = requireOption(opts.member, "--member", "verify-sig");
+  const message = await resolveMessage(opts);
+  const signature = await resolveBytesArg(sigArg, "--signature", true);
+  const member = await resolveBytesArg(memberArg, "--member");
+  const valid = verifyBandersnatchSig(signature, message, member);
+  if (!valid) {
+    throw new CliError("Bandersnatch signature is invalid.");
+  }
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ valid: true }));
+  } else {
+    printHeading("Bandersnatch Signature Verification");
+    console.log(`  ${BOLD}Valid:${RESET} yes`);
+    console.log();
+  }
+}
+async function membersCmd(rest, opts) {
+  if (rest.length === 0) {
+    throw new CliError("dot verifiable members requires one or more 0x-hex member keys.");
+  }
+  const memberBytes = rest.map((k) => {
+    const bytes = parseInputData(k);
+    if (bytes.length !== 32) {
+      throw new CliError(`member key must be 32 bytes (got ${bytes.length}): ${k}`);
+    }
+    return bytes;
+  });
+  const encoded = toHex2(encodeMembers(memberBytes));
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({ count: rest.length, members: encoded }));
+  } else {
+    printHeading("Encoded Members");
+    console.log(`  ${BOLD}Count:${RESET}   ${rest.length}`);
+    console.log(`  ${BOLD}Members:${RESET} ${encoded}`);
+    console.log();
+  }
+}
+var init_commands = __esm(() => {
+  init_platform();
+  init_lib();
+});
+
 // src/completions/complete.ts
 var exports_complete = {};
 __export(exports_complete, {
@@ -3628,7 +4166,16 @@ var init_complete = __esm(() => {
     ext: "extensions",
     rpc: "rpc"
   };
-  NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "completions"];
+  NAMED_COMMANDS = [
+    "chain",
+    "account",
+    "inspect",
+    "hash",
+    "sign",
+    "completions",
+    "init",
+    "which"
+  ];
   CHAIN_SUBCOMMANDS = ["add", "info", "list", "remove", "update"];
   ACCOUNT_SUBCOMMANDS = [
     "add",
@@ -3660,17 +4207,17 @@ var init_complete = __esm(() => {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "1.19.0";
+var version = "1.21.0";
 
 // src/commands/account.ts
 init_accounts_store();
 init_accounts();
 import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import { hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
+import { hexToBytes as nobleHexToBytes2 } from "@noble/hashes/utils.js";
 
 // src/core/h160.ts
 import { keccak_256 } from "@noble/hashes/sha3.js";
-import { bytesToHex as bytesToHex2, hexToBytes } from "@noble/hashes/utils.js";
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
 var ETH_DERIVED_SUFFIX_BYTE = 238;
 var H160_LEN = 20;
 var ACCOUNT_ID_LEN = 32;
@@ -3722,7 +4269,7 @@ function h160FromHex(input) {
   if (!isH160Hex(input)) {
     throw new Error(`Not a valid 0x-prefixed 20-byte hex string: ${input}`);
   }
-  return hexToBytes(input.slice(2));
+  return hexToBytes2(input.slice(2));
 }
 
 // src/commands/account.ts
@@ -3797,7 +4344,8 @@ function isValidParaId(value) {
 var ACCOUNT_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot account add <name> <ss58|hex>                                Add a watch-only address (no secret)
-  $ dot account add <name> --secret <s> [--path <derivation>]        Import from BIP39 mnemonic
+  $ dot account add <name> --secret <s> [--path <derivation>]        Import from BIP39 mnemonic or 32-byte hex seed
+  $ dot account add <name> --secret 0x<128 hex>                      Import a raw 64-byte sr25519 private key (no --path)
   $ dot account add <name> --env <VAR> [--path <derivation>]         Import account backed by env variable
   $ dot account add <name> --parachain <id> --parachain-type <t>     Derive a parachain sovereign (t = child|sibling)
   $ dot account add <name> --pallet-id <8 chars or 0x hex>           Derive a pallet sovereign (e.g. py/trsry)
@@ -3814,6 +4362,7 @@ ${BOLD}Usage:${RESET}
 ${BOLD}Examples:${RESET}
   $ dot account add treasury 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
   $ dot account add treasury --secret "word1 word2 ... word12"
+  $ dot account add raw-key --secret 0x<128-hex-char sr25519 expanded secret>
   $ dot account add ci-signer --env MY_SECRET --path //ci
   $ dot account add Treasury --pallet-id py/trsry
   $ dot account add Bounties --pallet-id 0x70792f626f756e74
@@ -3841,16 +4390,21 @@ ${BOLD}Examples:${RESET}
 
 ${YELLOW}Note: Secrets are stored unencrypted in ~/.polkadot/accounts.json.
       Use --env to keep secrets off disk entirely.
-      Hex seed import (0x...) is not supported via CLI.${RESET}
+      --secret accepts a BIP39 mnemonic, a 0x 32-byte hex seed, or a
+      0x 64-byte raw sr25519 private key (the value --show-secret prints).
+      Raw private keys cannot be HD-derived, so --path is rejected for them.${RESET}
 `.trimStart();
 function registerAccountCommands(cli) {
-  cli.command("account [action] [...names]", "Manage local accounts (create, import, list, remove, export)").alias("accounts").option("--secret <value>", "Secret key (mnemonic or hex seed) for import").option("--env <varName>", "Environment variable name holding the secret").option("--path <derivation>", "Derivation path (e.g. //staking, //polkadot//0/wallet)").option("--parachain <id>", "Derive a parachain sovereign account (requires --parachain-type)").option("--parachain-type <type>", "Parachain sovereign type: child or sibling").option("--pallet-id <id>", "Derive a pallet sovereign account from an 8-byte PalletId").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").option("--file <path>", "Input/output file for batch import/export").option("--overwrite", "Overwrite existing accounts on batch import").option("--dry-run", "Preview batch import without applying changes").option("--include-secrets", "Include secrets in export (redacted by default)").option("--watch-only", "Export only watch-only accounts").option("--show-secret", "Reveal the 64-byte sr25519 expanded private key (inspect only)").action(async (action, names, opts) => {
+  cli.command("account [action] [...names]", "Manage local accounts (create, import, list, remove, export)").alias("accounts").option("--secret <value>", "Secret for import: BIP39 mnemonic, 0x 32-byte hex seed, or 0x 64-byte raw private key").option("--env <varName>", "Environment variable name holding the secret").option("--path <derivation>", "Derivation path (e.g. //staking, //polkadot//0/wallet)").option("--parachain <id>", "Derive a parachain sovereign account (requires --parachain-type)").option("--parachain-type <type>", "Parachain sovereign type: child or sibling").option("--pallet-id <id>", "Derive a pallet sovereign account from an 8-byte PalletId").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").option("--file <path>", "Input/output file for batch import/export").option("--overwrite", "Overwrite existing accounts on batch import").option("--dry-run", "Preview batch import without applying changes").option("--include-secrets", "Include secrets in export (redacted by default)").option("--watch-only", "Export only watch-only accounts").option("--show-secret", "Reveal the 64-byte sr25519 expanded private key (inspect only)").action(async (action, names, opts) => {
     if (!action) {
       if (process.argv[2] === "accounts")
         return accountList(opts);
       console.log(ACCOUNT_HELP);
       return;
     }
+    const rawSecret = rawArgValue("--secret");
+    if (rawSecret != null)
+      opts.secret = rawSecret;
     switch (action) {
       case "new":
       case "create":
@@ -3900,7 +4454,7 @@ async function accountCreate(name, opts) {
   const { mnemonic, publicKey } = createNewAccount(path);
   const hexPub = publicKeyToHex(publicKey);
   const address = toSs58(publicKey);
-  const { deriveBandersnatchMember: deriveBandersnatchMember2 } = await Promise.resolve().then(() => (init_bandersnatch(), exports_bandersnatch));
+  const { deriveBandersnatchMember: deriveBandersnatchMember2 } = await Promise.resolve().then(() => (init_lib(), exports_lib));
   const bandersnatch = {};
   bandersnatch[""] = publicKeyToHex(deriveBandersnatchMember2(mnemonic));
   bandersnatch.candidate = publicKeyToHex(deriveBandersnatchMember2(mnemonic, "candidate"));
@@ -4492,8 +5046,9 @@ async function accountInspect(input, opts) {
     }
   }
   const ss58 = toSs58(publicKeyHex, prefix);
-  const h160Hex = toEip55(accountIdToH160(nobleHexToBytes(publicKeyHex.slice(2))));
+  const h160Hex = toEip55(accountIdToH160(nobleHexToBytes2(publicKeyHex.slice(2))));
   let privateKeyHex;
+  let revealedSecret;
   if (opts.showSecret) {
     if (!name) {
       console.error("--show-secret requires an account name; raw addresses and hex keys have no secret to reveal.");
@@ -4509,6 +5064,14 @@ async function accountInspect(input, opts) {
       console.error(err.message);
       process.exit(1);
     }
+    if (storedAccount?.secret !== undefined && !isEnvSecret(storedAccount.secret)) {
+      const kind = secretKind(storedAccount.secret);
+      if (kind === "mnemonic") {
+        revealedSecret = { label: "Mnemonic", field: "mnemonic", value: storedAccount.secret };
+      } else if (kind === "seed") {
+        revealedSecret = { label: "Seed", field: "seed", value: storedAccount.secret };
+      }
+    }
   }
   let kindLabel;
   let sourceLine;
@@ -4587,6 +5150,8 @@ async function accountInspect(input, opts) {
       result.env = envLine.replace(/^\$/, "");
     if (bandersnatch && Object.keys(bandersnatch).length > 0)
       result.bandersnatch = bandersnatch;
+    if (revealedSecret)
+      result[revealedSecret.field] = revealedSecret.value;
     if (privateKeyHex)
       result.privateKey = privateKeyHex;
     console.log(formatJson(result));
@@ -4618,6 +5183,12 @@ async function accountInspect(input, opts) {
       }
     }
     console.log(`  ${BOLD}Prefix:${RESET}      ${prefix}`);
+    if (revealedSecret) {
+      console.log(`  ${BOLD}${`${revealedSecret.label}:`.padEnd(13)}${RESET}${revealedSecret.value}`);
+      if (derivationLine) {
+        console.log(`               ${YELLOW}(derived with ${derivationLine} — re-import needs --path ${derivationLine})${RESET}`);
+      }
+    }
     if (privateKeyHex) {
       console.log(`  ${BOLD}Private Key:${RESET} ${privateKeyHex}`);
       console.log(`               ${YELLOW}(sr25519 expanded, 64 bytes — never share)${RESET}`);
@@ -5540,7 +6111,7 @@ function registerCompletionsCommand(cli) {
       process.exit(1);
     }
     const instructions = SETUP_INSTRUCTIONS[shell];
-    if (instructions) {
+    if (instructions && process.stdout.isTTY) {
       process.stderr.write(`${instructions}
 `);
     }
@@ -6321,30 +6892,9 @@ async function handleExtensions(target, opts) {
 
 // src/commands/hash.ts
 init_hash();
+init_input();
 init_output();
 init_errors();
-import { readFile as readFile5 } from "node:fs/promises";
-async function resolveInput(data, opts) {
-  const sources = [data !== undefined, !!opts.file, !!opts.stdin].filter(Boolean).length;
-  if (sources > 1) {
-    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 readFile5(opts.file);
-    return new Uint8Array(buf);
-  }
-  if (opts.stdin) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    return new Uint8Array(Buffer.concat(chunks));
-  }
-  return parseInputData(data);
-}
 function printAlgorithmHelp() {
   console.log(`${BOLD}Usage:${RESET} dot hash <algorithm> <data> [options]
 `);
@@ -6373,7 +6923,7 @@ function registerHashCommand(cli) {
     if (!isValidAlgorithm(algorithm)) {
       throw new CliError(suggestMessage("algorithm", algorithm, getAlgorithmNames()));
     }
-    const input = await resolveInput(data, opts);
+    const input = await resolveDataInput(data, opts);
     const hash = computeHash(algorithm, input);
     const hexHash = toHex2(hash);
     if (isJsonOutput(opts)) {
@@ -7279,9 +7829,9 @@ async function handleRpc(method, args, opts) {
 // src/commands/sign.ts
 init_accounts();
 init_hash();
+init_input();
 init_output();
 init_errors();
-import { readFile as readFile6 } from "node:fs/promises";
 var SUPPORTED_TYPES = ["sr25519"];
 function isSupportedType(type) {
   return SUPPORTED_TYPES.includes(type.toLowerCase());
@@ -7292,27 +7842,6 @@ function variantName(type) {
       return "Sr25519";
   }
 }
-async function resolveInput2(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 readFile6(opts.file);
-    return new Uint8Array(buf);
-  }
-  if (opts.stdin) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    return new Uint8Array(Buffer.concat(chunks));
-  }
-  return parseInputData(data);
-}
 function printSignHelp() {
   console.log(`${BOLD}Usage:${RESET} dot sign <message> --from <account> [options]
 `);
@@ -7346,7 +7875,7 @@ function registerSignCommand(cli) {
     if (!isSupportedType(type)) {
       throw new CliError(`Unsupported signature type "${opts.type}". Supported: ${SUPPORTED_TYPES.join(", ")}`);
     }
-    const input = await resolveInput2(message, opts);
+    const input = await resolveDataInput(message, opts);
     const keypair = await resolveAccountKeypair(opts.from);
     const signature = keypair.sign(input);
     const hexMessage = toHex2(input);
@@ -8718,7 +9247,7 @@ function buildGeneralTx(meta, callData, userExtOverrides) {
 }
 function watchTransaction(observable, level, options) {
   const spinner = new Spinner;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     spinner.start(options?.unsigned ? "Submitting..." : "Signing...");
     const subscription = observable.subscribe({
@@ -8738,7 +9267,7 @@ function watchTransaction(observable, level, options) {
               spinner.succeed("Broadcasted");
               settled = true;
               subscription.unsubscribe();
-              resolve(event);
+              resolve2(event);
             } else {
               spinner.succeed("Broadcasted");
               spinner.start("In best block...");
@@ -8750,7 +9279,7 @@ function watchTransaction(observable, level, options) {
                 spinner.succeed(`In best block #${event.block.number}`);
                 settled = true;
                 subscription.unsubscribe();
-                resolve(event);
+                resolve2(event);
               } else {
                 spinner.succeed(`In best block #${event.block.number}`);
                 spinner.start("Finalizing...");
@@ -8762,7 +9291,7 @@ function watchTransaction(observable, level, options) {
           case "finalized":
             spinner.succeed(`Finalized in block #${event.block.number}`);
             settled = true;
-            resolve(event);
+            resolve2(event);
             break;
         }
       },
@@ -8776,7 +9305,7 @@ function watchTransaction(observable, level, options) {
   });
 }
 function watchTransactionJson(observable, level, options) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const subscription = observable.subscribe({
       next(event) {
@@ -8793,7 +9322,7 @@ function watchTransactionJson(observable, level, options) {
             if (level === "broadcast") {
               settled = true;
               subscription.unsubscribe();
-              resolve(event);
+              resolve2(event);
             }
             break;
           case "txBestBlocksState":
@@ -8802,13 +9331,13 @@ function watchTransactionJson(observable, level, options) {
               if (level === "best-block") {
                 settled = true;
                 subscription.unsubscribe();
-                resolve(event);
+                resolve2(event);
               }
             }
             break;
           case "finalized":
             settled = true;
-            resolve(event);
+            resolve2(event);
             break;
         }
       },
@@ -8821,119 +9350,91 @@ function watchTransactionJson(observable, level, options) {
   });
 }
 
-// src/commands/verifiable.ts
-init_accounts_store();
-init_accounts();
-init_bandersnatch();
+// src/commands/workspace.ts
+init_store();
+init_workspace();
 init_output();
-var DEV_PHRASE2 = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-var VERIFIABLE_HELP = `
-${BOLD}Usage:${RESET}
-  $ dot verifiable <account> [--context <value>]
-
-${BOLD}Arguments:${RESET}
-  account    Account name (stored or dev account)
-
-${BOLD}Options:${RESET}
-  --context <value>    Blake2b context for keyed derivation (e.g. "candidate")
-
-${BOLD}Examples:${RESET}
-  $ dot verifiable alice                            Unkeyed derivation (lite person)
-  $ dot verifiable alice --context candidate         Keyed with "candidate" (full person)
-  $ dot verifiable my-account --context candidate
-
-${BOLD}How it works:${RESET}
-
-  Mnemonic (12/24 words)
-      │  mnemonicToEntropy()  (raw BIP39 entropy, NOT miniSecret)
-      ▼
-  blake2b256(entropy, context?)   keyed or unkeyed
-      ▼
-  member_from_entropy()       verifiablejs WASM (Bandersnatch curve)
-      ▼
-  32-byte member key          for on-chain member set registration
-`.trimStart();
-function registerVerifiableCommands(cli) {
-  cli.command("verifiable [account]", "Derive Bandersnatch member key from account mnemonic").option("--context <value>", "Blake2b context for keyed derivation (e.g. candidate)").action(async (account, opts) => {
-    if (!account) {
-      console.log(VERIFIABLE_HELP);
-      return;
-    }
-    return deriveVerifiable(account, opts);
-  });
-}
-async function deriveVerifiable(account, opts) {
-  const mnemonic = await resolveMnemonic(account);
-  const memberKey = deriveBandersnatchMember(mnemonic, opts.context);
-  const memberKeyHex = publicKeyToHex(memberKey);
-  if (!isDevAccount(account)) {
-    const accountsFile = await loadAccounts();
-    const stored = findAccount(accountsFile, account);
-    if (stored) {
-      if (!stored.bandersnatch)
-        stored.bandersnatch = {};
-      stored.bandersnatch[opts.context ?? ""] = memberKeyHex;
-      await saveAccounts(accountsFile);
-    }
+init_errors();
+import { mkdir as mkdir3, stat } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+async function initWorkspace(cwd, home = homedir3()) {
+  const dir = canonicalPath(cwd);
+  if (dir === canonicalPath(home)) {
+    throw new CliError(`Cannot initialize a workspace in your home directory — ${join4(dir, WORKSPACE_DIR_NAME)} is the global config root.`);
   }
-  if (isJsonOutput(opts)) {
-    const result = {
-      account,
-      memberKey: memberKeyHex
-    };
-    if (opts.context)
-      result.context = opts.context;
-    console.log(formatJson(result));
-  } else {
-    printHeading("Bandersnatch Member Key");
-    console.log(`  ${BOLD}Account:${RESET}    ${account}`);
-    if (opts.context)
-      console.log(`  ${BOLD}Context:${RESET}    ${opts.context}`);
-    console.log(`  ${BOLD}Member Key:${RESET} ${memberKeyHex}`);
-    console.log();
+  const workspacePath = join4(dir, WORKSPACE_DIR_NAME);
+  const exists = await stat(workspacePath).then(() => true).catch(() => false);
+  if (exists) {
+    throw new CliError(`A workspace already exists at ${workspacePath}.`);
   }
-}
-async function resolveMnemonic(account) {
-  if (isDevAccount(account)) {
-    return DEV_PHRASE2;
+  const warnings = [];
+  const parentWorkspace = findWorkspace(dir, home);
+  if (parentWorkspace) {
+    warnings.push(`This workspace shadows ${parentWorkspace} for commands run below ${dir}.`);
   }
-  const accountsFile = await loadAccounts();
-  const stored = findAccount(accountsFile, account);
-  if (!stored) {
-    const available = [...DEV_NAMES, ...accountsFile.accounts.map((a) => a.name)].sort((a, b) => a.localeCompare(b));
-    const suggestions = findClosest(account, available);
-    const hint = suggestions.length > 0 ? `
-  Did you mean: ${suggestions.join(", ")}?` : "";
-    const list = available.map((a) => `
-    - ${a}`).join("");
-    throw new Error(`Unknown account "${account}".${hint}
-  Available accounts:${list}`);
+  const dotHome = process.env.DOT_HOME;
+  if (dotHome && dotHome.length > 0) {
+    warnings.push(`DOT_HOME is set (${dotHome}) and takes precedence — this workspace will not be picked up until you unset it.`);
   }
-  if (isWatchOnly(stored)) {
-    throw new Error(`Account "${account}" is watch-only (no secret). Cannot derive Bandersnatch key.`);
+  await mkdir3(workspacePath, { recursive: true });
+  return { workspacePath, warnings };
+}
+var SOURCE_LABELS = {
+  env: "DOT_HOME environment variable",
+  workspace: "local workspace (discovered from current directory)",
+  global: "global config"
+};
+async function handleInit(cwd = process.cwd()) {
+  const result = await initWorkspace(cwd);
+  for (const warning of result.warnings) {
+    process.stderr.write(`Warning: ${warning}
+`);
   }
-  const secret = resolveSecret(stored.secret);
-  if (isHexPublicKey(`0x${secret.replace(/^0x/, "")}`)) {
-    throw new Error(`Account "${account}" uses a hex seed. Bandersnatch derivation requires a BIP39 mnemonic.`);
+  await writeStdout(`Initialized empty dot workspace at ${result.workspacePath}
+` + `Check which workspace is active with: dot which
+`);
+}
+async function handleWhich(opts, cwd = process.cwd()) {
+  const resolved = resolveConfigDir(cwd);
+  if (isJsonOutput(opts)) {
+    await writeStdout(`${JSON.stringify({ path: resolved.path, source: resolved.source })}
+`);
+    return;
   }
-  return secret;
+  await writeStdout(`${resolved.path}
+Source: ${SOURCE_LABELS[resolved.source]}
+`);
+}
+function registerWorkspaceCommands(cli) {
+  cli.command("init", "Initialize a local .polkadot workspace in the current directory").action(() => handleInit());
+  cli.command("which", "Show the active config root (workspace, DOT_HOME, or global)").action((opts) => handleWhich(opts));
 }
 
 // src/config/store.ts
 init_errors();
 init_types();
-import { access as access3, mkdir as mkdir3, readFile as readFile7, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
-function getConfigDir2() {
+init_workspace();
+import { access as access3, mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+function resolveConfigDir2(cwd = process.cwd()) {
   const override = process.env.DOT_HOME;
-  return override && override.length > 0 ? override : join3(homedir2(), ".polkadot");
+  if (override && override.length > 0)
+    return { path: override, source: "env" };
+  const workspace = findWorkspace(cwd);
+  if (workspace)
+    return { path: workspace, source: "workspace" };
+  return { path: join5(homedir4(), ".polkadot"), source: "global" };
+}
+function getConfigDir2() {
+  return resolveConfigDir2().path;
 }
 function getConfigPath2() {
-  return join3(getConfigDir2(), "config.json");
+  return join5(getConfigDir2(), "config.json");
 }
 async function ensureDir3(dir) {
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
 }
 async function fileExists3(path) {
   try {
@@ -8947,7 +9448,7 @@ async function loadConfig2() {
   await ensureDir3(getConfigDir2());
   const configPath = getConfigPath2();
   if (await fileExists3(configPath)) {
-    const saved = JSON.parse(await readFile7(configPath, "utf-8"));
+    const saved = JSON.parse(await readFile6(configPath, "utf-8"));
     const chains = {};
     for (const [name, defaultConfig] of Object.entries(DEFAULT_CONFIG.chains)) {
       chains[name] = saved.chains[name] ? { ...defaultConfig, ...saved.chains[name] } : defaultConfig;
@@ -8970,7 +9471,7 @@ async function saveConfig2(config) {
 
 // src/core/file-loader.ts
 init_errors();
-import { access as access4, readFile as readFile8 } from "node:fs/promises";
+import { access as access4, readFile as readFile7 } from "node:fs/promises";
 import { parse as parseYaml } from "yaml";
 var CATEGORIES = ["tx", "query", "const", "apis"];
 var FILE_EXTENSIONS = [".json", ".yaml", ".yml"];
@@ -9035,7 +9536,7 @@ async function loadCommandFile(filePath, cliVars) {
   } catch {
     throw new CliError(`File not found: ${filePath}`);
   }
-  const rawText = await readFile8(filePath, "utf-8");
+  const rawText = await readFile7(filePath, "utf-8");
   if (!rawText.trim()) {
     throw new CliError(`File is empty: ${filePath}`);
   }
@@ -9107,8 +9608,8 @@ async function loadCommandFile(filePath, cliVars) {
 // src/core/update-notifier.ts
 init_store();
 import { readFileSync } from "node:fs";
-import { mkdir as mkdir4, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var CACHE_FILE = "update-check.json";
 var STALE_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 5000;
@@ -9164,7 +9665,7 @@ function buildNotificationBox(current, latest) {
 `);
 }
 function getCachePath() {
-  return join4(getConfigDir(), CACHE_FILE);
+  return join6(getConfigDir(), CACHE_FILE);
 }
 function readCache() {
   try {
@@ -9176,7 +9677,7 @@ function readCache() {
 }
 async function writeCache(cache) {
   try {
-    await mkdir4(getConfigDir(), { recursive: true });
+    await mkdir5(getConfigDir(), { recursive: true });
     await writeFile6(getCachePath(), `${JSON.stringify(cache)}
 `);
   } catch {}
@@ -9204,7 +9705,7 @@ function startBackgroundCheck(currentVersion) {
 async function waitForPendingCheck() {
   if (!pendingCheck)
     return;
-  const timeout = new Promise((resolve) => setTimeout(resolve, EXIT_WAIT_TIMEOUT_MS));
+  const timeout = new Promise((resolve2) => setTimeout(resolve2, EXIT_WAIT_TIMEOUT_MS));
   await Promise.race([pendingCheck.catch(() => {}), timeout]);
   pendingCheck = null;
 }
@@ -9224,6 +9725,117 @@ function getUpdateNotification(currentVersion) {
   return null;
 }
 
+// src/features/verifiable/register.ts
+init_platform();
+var VERIFIABLE_HELP = `
+${BOLD}Usage:${RESET}
+  $ dot verifiable [account] [--entropy-key <key>]       Derive the member key (default action)
+  $ dot verifiable <action> [account] [options]
+
+${BOLD}Actions:${RESET}
+  member <account>      Derive the Bandersnatch member key (default if omitted)
+  alias  <account>      Derive the alias for a 32-byte ring context
+  sign   <account>      Standalone Bandersnatch signature (64 bytes)
+  prove  <account>      Ring-VRF proof (one_shot) over a members set
+  verify                Locally verify a ring-VRF proof against members/root
+  verify-sig            Verify a standalone Bandersnatch signature
+  members <key…>        SCALE-encode member keys as Vec<[u8;32]>
+
+  verify / verify-sig exit non-zero on failure (the verdict is the exit code);
+  on success they print the recovered alias / {"valid":true}.
+
+${BOLD}Key concepts (do not conflate these):${RESET}
+  --entropy-key <text|0xhex>
+        Key mixed into the keyed-blake2b that turns your mnemonic into the
+        Bandersnatch member entropy. Omit for a ${BOLD}lite${RESET} person (unkeyed);
+        use "candidate" for a ${BOLD}full${RESET} person. Must match the key used when the
+        member was recognised on-chain, or you derive a different (unrecognised)
+        member key. It is NOT a derivation path and NOT the ring --context.
+  --context <text|0xhex>
+        The 32-byte ring/proof namespace (e.g. "dotns"), zero-padded right to 32
+        bytes like Solidity bytes32(). Determines the alias. Used by alias/prove/verify.
+
+${BOLD}Options:${RESET}
+  --entropy-key <key>   Entropy-derivation key (see above)
+  --context <value>     32-byte ring context (alias/prove/verify)
+  --message <data>      Message to sign / bind / verify (text or 0x hex)
+  --file <path>         Read the message from a file (raw bytes)
+  --stdin               Read the message from stdin
+  --members <hex|file>  SCALE-encoded Vec<[u8;32]> ring (prove/verify)
+  --root <hex>          768-byte ring root / commitment (verify)
+  --proof <hex>         Ring-VRF proof bytes (verify)
+  --signature <hex>     Bandersnatch signature (verify-sig)
+  --member <hex>        32-byte member public key (verify-sig)
+  --ring-exponent <n>   Ring exponent: 9 (default), 10, or 14
+  --output json         Output as JSON
+
+${BOLD}Examples:${RESET}
+  $ dot verifiable alice                                 Lite member key
+  $ dot verifiable alice --entropy-key candidate         Full member key
+  $ dot verifiable alias alice --entropy-key candidate --context dotns
+  $ dot verifiable sign alice --message "hello" --entropy-key candidate
+  $ dot verifiable prove alice --entropy-key candidate --context dotns \\
+      --message 0x… --members 0x…
+  $ dot verifiable verify --proof 0x… --context dotns --message 0x… --members 0x…
+  $ dot verifiable members 0x… 0x…
+
+${BOLD}Derivation flow:${RESET}
+
+  Mnemonic ─BIP39─▶ entropy ─keyed blake2b─▶ member entropy ─▶ member key / secret
+                              (key = --entropy-key)                  │
+                                                  ring proof: one_shot(…, --context, --message)
+`.trimStart();
+var RAW_STRING_FLAGS = [
+  ["entropy-key", "entropyKey"],
+  ["context", "context"],
+  ["message", "message"],
+  ["members", "members"],
+  ["root", "root"],
+  ["proof", "proof"],
+  ["signature", "signature"],
+  ["member", "member"]
+];
+function registerVerifiableCommands(cli) {
+  cli.command("verifiable [action] [...rest]", "Bandersnatch member keys, ring-VRF proofs, signing and verification").option("--entropy-key <key>", "Entropy-derivation key (omit = lite, 'candidate' = full)").option("--context <value>", "32-byte ring/proof context (alias/prove/verify)").option("--message <data>", "Message to sign/bind/verify (text or 0x hex)").option("--file <path>", "Read message from a file (raw bytes)").option("--stdin", "Read message from stdin").option("--members <hex|file>", "SCALE-encoded Vec<[u8;32]> ring (prove/verify)").option("--root <hex>", "768-byte ring root/commitment (verify)").option("--proof <hex>", "Ring-VRF proof bytes (verify)").option("--signature <hex>", "Bandersnatch signature (verify-sig)").option("--member <hex>", "32-byte member public key (verify-sig)").option("--ring-exponent <n>", "Ring exponent: 9 (default), 10, or 14").action(async (action, rest, opts) => {
+    if (!action) {
+      console.log(VERIFIABLE_HELP);
+      return;
+    }
+    for (const [flag, key] of RAW_STRING_FLAGS) {
+      const raw = readRawOptionValue(flag);
+      if (raw !== undefined)
+        opts[key] = raw;
+    }
+    const { runVerifiable: runVerifiable2 } = await Promise.resolve().then(() => (init_commands(), exports_commands));
+    return runVerifiable2(action, rest, opts);
+  });
+}
+
+// src/platform/cli.ts
+function registerGlobalOptions(cli) {
+  cli.option("--chain <name>", "Target chain (required)");
+  cli.option("--rpc <url>", "Override RPC endpoint for this call");
+  cli.option("--output <format>", "Output format: pretty or json", {
+    default: "pretty"
+  });
+  cli.option("--json", "Output as JSON (shorthand for --output json)");
+}
+function readRawOptionValue2(name, argv = process.argv) {
+  const flag = `--${name}`;
+  const prefix = `${flag}=`;
+  let value;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--")
+      break;
+    if (arg === flag && i + 1 < argv.length)
+      value = argv[i + 1];
+    else if (arg.startsWith(prefix))
+      value = arg.slice(prefix.length);
+  }
+  return value;
+}
+
 // src/utils/errors.ts
 class CliError2 extends Error {
   constructor(message) {
@@ -9346,15 +9958,7 @@ if (process.argv[2] === "__complete") {
     process.exit(0);
   })();
 } else {
-  let readAtFromArgv = function(argv) {
-    for (let i = 0;i < argv.length; i++) {
-      if (argv[i] === "--at" && i + 1 < argv.length)
-        return argv[i + 1];
-      if (argv[i].startsWith("--at="))
-        return argv[i].slice(5);
-    }
-    return;
-  }, collectVarFlags = function(argv) {
+  let collectVarFlags = function(argv) {
     const vars = [];
     for (let i = 0;i < argv.length; i++) {
       if (argv[i] === "--var" && i + 1 < argv.length) {
@@ -9410,8 +10014,10 @@ if (process.argv[2] === "__complete") {
     console.log("  hash               Hash utilities");
     console.log("  sign               Sign a message with an account keypair");
     console.log("  parachain          Derive parachain sovereign accounts (deprecated \u2014 use `account inspect --parachain`)");
-    console.log("  verifiable         Derive Bandersnatch member key from mnemonic");
+    console.log("  verifiable         Bandersnatch member keys, ring-VRF proofs, sign/verify");
     console.log("  completions <sh>   Generate shell completions (zsh, bash, fish)");
+    console.log("  init               Initialize a local .polkadot workspace in this directory");
+    console.log("  which              Show the active config root (workspace, DOT_HOME, or global)");
     console.log();
     console.log("Global options:");
     console.log("  --chain <name>     Target chain (required)");
@@ -9423,12 +10029,7 @@ if (process.argv[2] === "__complete") {
   };
   startBackgroundCheck(version);
   const cli = cac("dot");
-  cli.option("--chain <name>", "Target chain (required)");
-  cli.option("--rpc <url>", "Override RPC endpoint for this call");
-  cli.option("--output <format>", "Output format: pretty or json", {
-    default: "pretty"
-  });
-  cli.option("--json", "Output as JSON (shorthand for --output json)");
+  registerGlobalOptions(cli);
   registerChainCommands(cli);
   registerInspectCommand(cli);
   registerMetadataCommand(cli);
@@ -9438,6 +10039,7 @@ if (process.argv[2] === "__complete") {
   registerParachainCommand(cli);
   registerCompletionsCommand(cli);
   registerVerifiableCommands(cli);
+  registerWorkspaceCommands(cli);
   cli.command("[dotpath] [...args]").option("--from <name>", "Account to sign with (for tx)").option("--dry-run", "Estimate fees without submitting (for tx)").option("--encode", "Encode call to hex without signing (for tx)").option("--to-yaml", "Decode call to YAML file format (for tx)").option("--to-json", "Decode call to JSON file format (for tx)").option("--ext <json>", "Custom signed extension values as JSON (for tx)").option("--asset <json>", "Pay fees in an alternative asset (XCM location JSON, for tx)").option("-w, --wait <level>", "Resolve at: broadcast, best-block (or best), finalized (for tx)", {
     default: "finalized"
   }).option("--dump", "Dump all entries of a storage map (without specifying a key)").option("--var <kv>", "Template variable for file input (KEY=VALUE, repeatable)").option("--nonce <n>", "Custom nonce for manual tx sequencing (for tx)").option("--tip <amount>", "Tip to prioritize transaction (for tx)").option("--mortality <spec>", '"immortal" or period number (for tx)').option("--at <block>", 'Block hash, "best", or "finalized" to read/validate against (tx, query, apis)').option("--unsigned", "Submit as unsigned/bare transaction (no signer required, for tx)").option("--refresh", "Refresh the cached RPC method list from the node (for rpc)").action(async (dotpath, args, opts) => {
@@ -9445,7 +10047,7 @@ if (process.argv[2] === "__complete") {
       printHelp();
       return;
     }
-    const atRaw = readAtFromArgv(process.argv);
+    const atRaw = readRawOptionValue2("at");
     if (isFilePath(dotpath)) {
       const cliVars = collectVarFlags(process.argv);
       const cmd = await loadCommandFile(dotpath, cliVars);