polkadot-cli 1.17.0 → 1.19.0

package/dist/cli.mjs

@@ -22,6 +22,12 @@ function isLikelyStaleMetadataError(err) {
     return false;
   return STALE_METADATA_PATTERNS.some((re) => re.test(msg));
 }
+function isBlockUnavailableError(err) {
+  const msg = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+  if (!msg)
+    return false;
+  return BLOCK_UNAVAILABLE_PATTERNS.some((re) => re.test(msg));
+}
 function formatRuntimeError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   if (/wasm trap|wasm `?unreachable`? instruction|Execution aborted due to trap/i.test(msg)) {
@@ -40,7 +46,7 @@ function formatRuntimeError(err) {
   }
   return msg;
 }
-var CliError, ConnectionError, MetadataError, STALE_METADATA_PATTERNS;
+var CliError, ConnectionError, MetadataError, STALE_METADATA_PATTERNS, BLOCK_UNAVAILABLE_PATTERNS;
 var init_errors = __esm(() => {
   CliError = class CliError extends Error {
     constructor(message) {
@@ -69,6 +75,11 @@ var init_errors = __esm(() => {
     /Lookup failed/i,
     /metadata.*mismatch/i
   ];
+  BLOCK_UNAVAILABLE_PATTERNS = [
+    /is not pinned/i,
+    /Invalid BlockHash/i,
+    /UnknownBlock.*Header was not found/i
+  ];
 });
 
 // src/utils/runtime-fingerprint.ts
@@ -240,6 +251,9 @@ function getMetadataPath(chainName) {
 function getMetadataFingerprintPath(chainName) {
   return join(getChainDir(chainName), "metadata.fingerprint.json");
 }
+function getRpcMethodsPath(chainName) {
+  return join(getChainDir(chainName), "rpc-methods.json");
+}
 function getConfigPath() {
   return join(getConfigDir(), "config.json");
 }
@@ -305,6 +319,31 @@ async function loadMetadataFingerprint(chainName) {
     return null;
   }
 }
+async function loadRpcMethods(chainName) {
+  const path = getRpcMethodsPath(chainName);
+  if (!await fileExists(path))
+    return null;
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf-8"));
+    if (parsed && Array.isArray(parsed.methods) && typeof parsed.version === "number" && typeof parsed.fetchedAt === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveRpcMethods(chainName, methods, version2) {
+  const dir = getChainDir(chainName);
+  await ensureDir(dir);
+  const cache = {
+    methods,
+    version: version2,
+    fetchedAt: new Date().toISOString()
+  };
+  await writeFile(getRpcMethodsPath(chainName), `${JSON.stringify(cache, null, 2)}
+`);
+}
 async function removeChainData(chainName) {
   const dir = getChainDir(chainName);
   await rm(dir, { recursive: true, force: true });
@@ -375,6 +414,15 @@ function isEnvSecret(secret) {
 function isWatchOnly(account) {
   return account.secret === undefined;
 }
+function classifyAccount(account) {
+  if (account.source?.kind === "pallet")
+    return "pallet";
+  if (account.source?.kind === "parachain")
+    return "parachain";
+  if (account.secret !== undefined)
+    return "signer";
+  return "watch-only";
+}
 
 // src/utils/fuzzy-match.ts
 function levenshtein(a, b) {
@@ -1216,7 +1264,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 = hexToBytes(hex);
+    const raw = hexToBytes2(hex);
     const decoded = optionalOpaqueBytes.dec(raw);
     if (decoded !== undefined) {
       bytes = new Uint8Array(decoded);
@@ -1225,7 +1273,7 @@ async function fetchMetadataFromChain(clientHandle, chainName) {
   if (!bytes) {
     try {
       const hex = await withTimeout(client._request("state_getMetadata", []), chainName);
-      bytes = hexToBytes(hex);
+      bytes = hexToBytes2(hex);
     } catch (err) {
       if (err instanceof ConnectionError)
         throw err;
@@ -1274,6 +1322,24 @@ async function withStalenessSuggestion(chainName, clientHandle, task) {
 ` + `   Run: dot chain update ${chainName}`);
   }
 }
+async function withBlockAvailabilityHint(atRaw, task) {
+  try {
+    return await task();
+  } catch (err) {
+    if (!isBlockUnavailableError(err))
+      throw err;
+    const original = err instanceof Error ? err.message : String(err);
+    const isExplicitHash = atRaw && atRaw !== "best" && atRaw !== "finalized";
+    const target = isExplicitHash ? atRaw : "the requested block";
+    const exampleAt = isExplicitHash ? atRaw : "<hash>";
+    throw new CliError(`${original}
+
+` + `⚠ ${target} is not available on the current RPC endpoint.
+` + `   Public nodes serve only recent (pinned) blocks via chainHead_v1_*.
+` + `   For deep historical reads, point --rpc at an archive endpoint, e.g.:
+` + `     dot ... --at ${exampleAt} --rpc wss://<archive-endpoint>`);
+  }
+}
 async function getOrFetchMetadata(chainName, clientHandle) {
   let raw = await loadMetadata(chainName);
   if (!raw) {
@@ -1403,7 +1469,7 @@ function describeCallArgs(meta, palletName, callName) {
 function describeEventFields(meta, palletName, eventName) {
   return compactArgsString(getEventFields(meta, palletName, eventName));
 }
-function hexToBytes(hex) {
+function hexToBytes2(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) {
@@ -1498,6 +1564,15 @@ import { compact as scaleCompact } from "@polkadot-api/substrate-bindings";
 import { getViewBuilder } from "@polkadot-api/view-builder";
 import { Binary as Binary2 } from "polkadot-api";
 import { stringify as stringifyYaml } from "yaml";
+function parseAtForRead(raw) {
+  if (raw === undefined)
+    return;
+  if (raw === "best" || raw === "finalized")
+    return raw;
+  if (/^0x[0-9a-fA-F]{64}$/.test(raw))
+    return raw;
+  throw new CliError(`Invalid --at value "${raw}". Use "best", "finalized", or a 0x-prefixed 32-byte block hash.`);
+}
 async function parseStructArgs(meta, fields, args, callLabel) {
   const fieldNames = Object.keys(fields);
   if (args.length !== fieldNames.length) {
@@ -1906,8 +1981,10 @@ async function handleApis(target, args, opts) {
       typeof opts.parsedArgs === "object" ? JSON.stringify(opts.parsedArgs) : String(opts.parsedArgs)
     ];
     const parsedArgs = await parseRuntimeApiArgs(meta, method, effectiveArgs);
+    const atArg = parseAtForRead(opts.at);
+    const pullOpts = atArg !== undefined ? [{ at: atArg }] : [];
     const unsafeApi = clientHandle.client.getUnsafeApi();
-    const result = await unsafeApi.apis[api.name][method.name](...parsedArgs);
+    const result = await withBlockAvailabilityHint(opts.at, () => unsafeApi.apis[api.name][method.name](...parsedArgs, ...pullOpts));
     const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     printResult(result, format);
   } finally {
@@ -2559,11 +2636,569 @@ var init_focused_inspect = __esm(() => {
   init_pretty_type();
 });
 
+// src/data/rpc-registry.ts
+function inferFamily(method) {
+  const prefix = method.split("_")[0];
+  switch (prefix) {
+    case "system":
+    case "chain":
+    case "state":
+    case "author":
+    case "payment":
+    case "babe":
+    case "grandpa":
+    case "beefy":
+    case "mmr":
+    case "offchain":
+    case "dev":
+      return prefix;
+    case "rpc":
+      return "spec";
+    case "chainHead":
+      return "chainHead";
+    case "chainSpec":
+      return "chainSpec";
+    case "transaction":
+      return "transaction";
+    case "archive":
+      return "archive";
+    default:
+      return "other";
+  }
+}
+var RPC_REGISTRY;
+var init_rpc_registry = __esm(() => {
+  RPC_REGISTRY = {
+    system_health: {
+      description: "Node sync state (peers, isSyncing, shouldHavePeers).",
+      family: "system",
+      args: []
+    },
+    system_syncState: {
+      description: "Block-level sync progress (startingBlock, currentBlock, highestBlock).",
+      family: "system",
+      args: []
+    },
+    system_version: {
+      description: "Node software version string.",
+      family: "system",
+      args: []
+    },
+    system_name: {
+      description: "Node implementation name.",
+      family: "system",
+      args: []
+    },
+    system_chain: {
+      description: "Chain name as reported by the node.",
+      family: "system",
+      args: []
+    },
+    system_chainType: {
+      description: "Chain type (Live, Development, Local).",
+      family: "system",
+      args: []
+    },
+    system_properties: {
+      description: "Chain properties (ss58Format, tokenDecimals, tokenSymbol).",
+      family: "system",
+      args: []
+    },
+    system_peers: {
+      description: "Connected peer details (peerId, roles, bestHash, bestNumber).",
+      family: "system",
+      args: []
+    },
+    system_localPeerId: {
+      description: "Base58 PeerId of this node.",
+      family: "system",
+      args: []
+    },
+    system_localListenAddresses: {
+      description: "Multiaddrs this node listens on.",
+      family: "system",
+      args: []
+    },
+    system_nodeRoles: {
+      description: "Role(s) of the node (Authority, Full, Light, …).",
+      family: "system",
+      args: []
+    },
+    system_addLogFilter: {
+      description: "Add a tracing/log filter directive at runtime.",
+      family: "system",
+      args: [{ name: "directives", type: "string" }],
+      dangerous: true
+    },
+    system_resetLogFilter: {
+      description: "Reset log filter to the default set at startup.",
+      family: "system",
+      args: [],
+      dangerous: true
+    },
+    system_accountNextIndex: {
+      description: "Next nonce for an account, including pending mempool extrinsics.",
+      family: "system",
+      args: [{ name: "address", type: "AccountId" }]
+    },
+    system_dryRun: {
+      description: "Dry-run an extrinsic, returning its ApplyExtrinsicResult.",
+      family: "system",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    chain_getBlock: {
+      description: "Full block (header + extrinsics) by hash.",
+      family: "chain",
+      args: [{ name: "blockHash", type: "H256", optional: true, description: "latest if omitted" }]
+    },
+    chain_getBlockHash: {
+      description: "Block hash by number, or latest if omitted.",
+      family: "chain",
+      args: [{ name: "blockNumber", type: "u32", optional: true }]
+    },
+    chain_getFinalizedHead: {
+      description: "Hash of the latest finalized head.",
+      family: "chain",
+      args: []
+    },
+    chain_getHeader: {
+      description: "Block header by hash, or latest if omitted.",
+      family: "chain",
+      args: [{ name: "blockHash", type: "H256", optional: true }]
+    },
+    chain_subscribeAllHeads: {
+      description: "Subscribe to all imported headers.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    chain_subscribeFinalizedHeads: {
+      description: "Subscribe to finalized-head changes.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    chain_subscribeNewHeads: {
+      description: "Subscribe to best-block-head changes.",
+      family: "chain",
+      args: [],
+      subscription: true
+    },
+    state_call: {
+      description: "Invoke a runtime API method by name with raw SCALE-encoded arguments.",
+      family: "state",
+      args: [
+        { name: "method", type: "string", description: "e.g. Core_version" },
+        { name: "data", type: "hex", description: "SCALE-encoded args (0x for none)" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getMetadata: {
+      description: "Raw SCALE-encoded runtime metadata at a block.",
+      family: "state",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    state_getRuntimeVersion: {
+      description: "Runtime version at a block.",
+      family: "state",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    state_getStorage: {
+      description: "Raw SCALE-encoded storage value at a key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getStorageHash: {
+      description: "Blake2 hash of the value at a storage key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getStorageSize: {
+      description: "Byte length of the value at a storage key.",
+      family: "state",
+      args: [
+        { name: "key", type: "StorageKey" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_getKeysPaged: {
+      description: "Paginated key iteration under a prefix.",
+      family: "state",
+      args: [
+        { name: "prefix", type: "StorageKey" },
+        { name: "count", type: "u32" },
+        { name: "startKey", type: "StorageKey", optional: true },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_queryStorageAt: {
+      description: "Read multiple keys at a single block.",
+      family: "state",
+      args: [
+        { name: "keys", type: "StorageKey[]" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    state_traceBlock: {
+      description: "Per-block storage access trace (heavy: archival/debug nodes only).",
+      family: "state",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "targets", type: "string", optional: true },
+        { name: "storageKeys", type: "string", optional: true },
+        { name: "methods", type: "string", optional: true }
+      ]
+    },
+    state_subscribeRuntimeVersion: {
+      description: "Subscribe to runtime upgrades.",
+      family: "state",
+      args: [],
+      subscription: true
+    },
+    state_subscribeStorage: {
+      description: "Subscribe to changes for a set of keys.",
+      family: "state",
+      args: [{ name: "keys", type: "StorageKey[]" }],
+      subscription: true
+    },
+    author_pendingExtrinsics: {
+      description: "Mempool snapshot — encoded extrinsics waiting to be included.",
+      family: "author",
+      args: []
+    },
+    author_submitExtrinsic: {
+      description: "Submit a signed extrinsic to the mempool. Returns the tx hash.",
+      family: "author",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true
+    },
+    author_removeExtrinsic: {
+      description: "Remove specific extrinsics from the mempool by hash.",
+      family: "author",
+      args: [{ name: "bytesOrHash", type: "ExtrinsicOrHash[]" }],
+      dangerous: true
+    },
+    author_hasKey: {
+      description: "Whether the keystore has the public key for a given key type.",
+      family: "author",
+      args: [
+        { name: "publicKey", type: "hex" },
+        { name: "keyType", type: "string", description: "e.g. babe, gran, imon" }
+      ]
+    },
+    author_hasSessionKeys: {
+      description: "Whether the keystore has all keys for a session-keys blob.",
+      family: "author",
+      args: [{ name: "sessionKeys", type: "hex" }]
+    },
+    author_rotateKeys: {
+      description: "Generate a new set of session keys and return the public-keys blob.",
+      family: "author",
+      args: [],
+      dangerous: true
+    },
+    author_insertKey: {
+      description: "Insert a key into the node keystore.",
+      family: "author",
+      args: [
+        { name: "keyType", type: "string" },
+        { name: "suri", type: "string" },
+        { name: "publicKey", type: "hex" }
+      ],
+      dangerous: true
+    },
+    author_submitAndWatchExtrinsic: {
+      description: "Submit an extrinsic and subscribe to its status updates.",
+      family: "author",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true,
+      subscription: true
+    },
+    payment_queryInfo: {
+      description: "Pre-submission fee estimate (weight, partialFee, class).",
+      family: "payment",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    payment_queryFeeDetails: {
+      description: "Fee breakdown (baseFee, lenFee, adjustedWeightFee, tip).",
+      family: "payment",
+      args: [
+        { name: "extrinsic", type: "hex" },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    babe_epochAuthorship: {
+      description: "Slots this node is allowed to author in the current epoch.",
+      family: "babe",
+      args: []
+    },
+    grandpa_proveFinality: {
+      description: "Finality proof up to a block (for light clients).",
+      family: "grandpa",
+      args: [{ name: "blockNumber", type: "u32" }]
+    },
+    grandpa_roundState: {
+      description: "GRANDPA round state (best round, total weight, voters).",
+      family: "grandpa",
+      args: []
+    },
+    grandpa_subscribeJustifications: {
+      description: "Subscribe to GRANDPA justifications.",
+      family: "grandpa",
+      args: [],
+      subscription: true
+    },
+    beefy_getFinalizedHead: {
+      description: "Latest BEEFY-finalized block hash.",
+      family: "beefy",
+      args: []
+    },
+    beefy_subscribeJustifications: {
+      description: "Subscribe to BEEFY signed commitments.",
+      family: "beefy",
+      args: [],
+      subscription: true
+    },
+    mmr_root: {
+      description: "MMR root at a block.",
+      family: "mmr",
+      args: [{ name: "at", type: "H256", optional: true }]
+    },
+    mmr_generateProof: {
+      description: "Generate an MMR proof for given leaf indices.",
+      family: "mmr",
+      args: [
+        { name: "blockNumbers", type: "u32[]" },
+        { name: "bestKnownBlockNumber", type: "u32", optional: true },
+        { name: "at", type: "H256", optional: true }
+      ]
+    },
+    mmr_verifyProof: {
+      description: "Verify an MMR proof.",
+      family: "mmr",
+      args: [{ name: "proof", type: "MmrLeavesProof" }]
+    },
+    offchain_localStorageGet: {
+      description: "Read from offchain-worker local storage (PERSISTENT or LOCAL kind).",
+      family: "offchain",
+      args: [
+        { name: "kind", type: "string", description: "PERSISTENT or LOCAL" },
+        { name: "key", type: "hex" }
+      ]
+    },
+    offchain_localStorageSet: {
+      description: "Write to offchain-worker local storage.",
+      family: "offchain",
+      args: [
+        { name: "kind", type: "string" },
+        { name: "key", type: "hex" },
+        { name: "value", type: "hex" }
+      ],
+      dangerous: true
+    },
+    dev_newBlock: {
+      description: "Manually trigger block production (manual-seal dev nodes).",
+      family: "dev",
+      args: [
+        {
+          name: "params",
+          type: "json",
+          optional: true,
+          description: "{ create_empty?: bool, finalize?: bool }"
+        }
+      ],
+      dangerous: true
+    },
+    dev_setHead: {
+      description: "Set the chain head to a specific block (manual-seal dev nodes).",
+      family: "dev",
+      args: [{ name: "blockHash", type: "H256" }],
+      dangerous: true
+    },
+    rpc_methods: {
+      description: "List of JSON-RPC methods this node exposes.",
+      family: "spec",
+      args: []
+    },
+    chainSpec_v1_chainName: {
+      description: "Chain name from the chain spec (no SCALE).",
+      family: "chainSpec",
+      args: []
+    },
+    chainSpec_v1_genesisHash: {
+      description: "Genesis block hash.",
+      family: "chainSpec",
+      args: []
+    },
+    chainSpec_v1_properties: {
+      description: "Chain properties from the chain spec.",
+      family: "chainSpec",
+      args: []
+    },
+    archive_v1_finalizedHeight: {
+      description: "Latest finalized block number this archive node has.",
+      family: "archive",
+      args: []
+    },
+    archive_v1_genesisHash: {
+      description: "Genesis block hash from the archive node.",
+      family: "archive",
+      args: []
+    },
+    archive_v1_hashByHeight: {
+      description: "Block hashes at a height (canonical + forks).",
+      family: "archive",
+      args: [{ name: "height", type: "u32" }]
+    },
+    archive_v1_header: {
+      description: "Header for an archived block.",
+      family: "archive",
+      args: [{ name: "blockHash", type: "H256" }]
+    },
+    archive_v1_body: {
+      description: "Block body (extrinsics) for an archived block.",
+      family: "archive",
+      args: [{ name: "blockHash", type: "H256" }]
+    },
+    archive_v1_call: {
+      description: "Invoke a runtime API at an archived block.",
+      family: "archive",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "function", type: "string" },
+        { name: "callParameters", type: "hex" }
+      ]
+    },
+    archive_v1_storage: {
+      description: "Read storage at an archived block.",
+      family: "archive",
+      args: [
+        { name: "blockHash", type: "H256" },
+        { name: "items", type: "StorageItemInput[]" },
+        { name: "childTrie", type: "string", optional: true }
+      ],
+      subscription: true
+    },
+    chainHead_v1_follow: {
+      description: "Pin chainHead and stream block events. Requires a follow session.",
+      family: "chainHead",
+      args: [{ name: "withRuntime", type: "bool" }],
+      subscription: true
+    },
+    transaction_v1_broadcast: {
+      description: "Broadcast a signed extrinsic and watch its status.",
+      family: "transaction",
+      args: [{ name: "extrinsic", type: "hex" }],
+      dangerous: true,
+      subscription: true
+    }
+  };
+});
+
+// src/core/xxh64.ts
+function rotl(v, r) {
+  return (v << r | v >> 64n - r) & MASK;
+}
+function round(acc, val) {
+  acc = acc + val * P2 & MASK;
+  acc = rotl(acc, 31n);
+  return acc * P1 & MASK;
+}
+function mergeRound(h, val) {
+  const k = round(0n, val);
+  return (h ^ k) * P1 + P4 & MASK;
+}
+function readU64LE(data, p) {
+  return BigInt(data[p]) | BigInt(data[p + 1]) << 8n | BigInt(data[p + 2]) << 16n | BigInt(data[p + 3]) << 24n | BigInt(data[p + 4]) << 32n | BigInt(data[p + 5]) << 40n | BigInt(data[p + 6]) << 48n | BigInt(data[p + 7]) << 56n;
+}
+function readU32LE(data, p) {
+  return BigInt(data[p]) | BigInt(data[p + 1]) << 8n | BigInt(data[p + 2]) << 16n | BigInt(data[p + 3]) << 24n;
+}
+function xxh64(input, seed = 0n) {
+  const len = input.length;
+  let p = 0;
+  let h;
+  if (len >= 32) {
+    let v1 = seed + P1 + P2 & MASK;
+    let v2 = seed + P2 & MASK;
+    let v3 = seed & MASK;
+    let v4 = seed - P1 & MASK;
+    while (p <= len - 32) {
+      v1 = round(v1, readU64LE(input, p));
+      p += 8;
+      v2 = round(v2, readU64LE(input, p));
+      p += 8;
+      v3 = round(v3, readU64LE(input, p));
+      p += 8;
+      v4 = round(v4, readU64LE(input, p));
+      p += 8;
+    }
+    h = rotl(v1, 1n) + rotl(v2, 7n) + rotl(v3, 12n) + rotl(v4, 18n) & MASK;
+    h = mergeRound(h, v1);
+    h = mergeRound(h, v2);
+    h = mergeRound(h, v3);
+    h = mergeRound(h, v4);
+  } else {
+    h = seed + P5 & MASK;
+  }
+  h = h + BigInt(len) & MASK;
+  while (p + 8 <= len) {
+    const k = round(0n, readU64LE(input, p));
+    h = rotl(h ^ k, 27n) * P1 + P4 & MASK;
+    p += 8;
+  }
+  if (p + 4 <= len) {
+    const k = readU32LE(input, p) * P1 & MASK;
+    h = rotl(h ^ k, 23n) * P2 + P3 & MASK;
+    p += 4;
+  }
+  while (p < len) {
+    const k = BigInt(input[p]) * P5 & MASK;
+    h = rotl(h ^ k, 11n) * P1 & MASK;
+    p++;
+  }
+  h ^= h >> 33n;
+  h = h * P2 & MASK;
+  h ^= h >> 29n;
+  h = h * P3 & MASK;
+  h ^= h >> 32n;
+  return h;
+}
+function u64ToLEBytes(v, out, offset) {
+  for (let i = 0;i < 8; i++) {
+    out[offset + i] = Number(v >> BigInt(i * 8) & 0xffn);
+  }
+}
+function twox(input, bits) {
+  const lanes = bits / 64;
+  const out = new Uint8Array(bits / 8);
+  for (let i = 0;i < lanes; i++) {
+    u64ToLEBytes(xxh64(input, BigInt(i)), out, i * 8);
+  }
+  return out;
+}
+var MASK, P1 = 11400714785074694791n, P2 = 14029467366897019727n, P3 = 1609587929392839161n, P4 = 9650029242287828579n, P5 = 2870177450012600261n;
+var init_xxh64 = __esm(() => {
+  MASK = (1n << 64n) - 1n;
+});
+
 // src/core/hash.ts
 import { blake2b as blake2b2 } from "@noble/hashes/blake2.js";
 import { sha256 } from "@noble/hashes/sha2.js";
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+import { keccak_256 as keccak_2562 } from "@noble/hashes/sha3.js";
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
 function computeHash(algorithm, data) {
   const algo = ALGORITHMS[algorithm];
   if (!algo) {
@@ -2577,12 +3212,12 @@ function parseInputData(input) {
     if (hex.length % 2 !== 0) {
       throw new Error(`Invalid hex input: odd number of characters`);
     }
-    return hexToBytes2(hex);
+    return hexToBytes3(hex);
   }
   return new TextEncoder().encode(input);
 }
 function toHex2(bytes) {
-  return `0x${bytesToHex2(bytes)}`;
+  return `0x${bytesToHex3(bytes)}`;
 }
 function isValidAlgorithm(name) {
   return name in ALGORITHMS;
@@ -2592,6 +3227,7 @@ function getAlgorithmNames() {
 }
 var ALGORITHMS;
 var init_hash = __esm(() => {
+  init_xxh64();
   ALGORITHMS = {
     blake2b256: {
       compute: (data) => blake2b2(data, { dkLen: 32 }),
@@ -2604,7 +3240,7 @@ var init_hash = __esm(() => {
       description: "BLAKE2b with 128-bit output"
     },
     keccak256: {
-      compute: (data) => keccak_256(data),
+      compute: (data) => keccak_2562(data),
       outputLen: 32,
       description: "Keccak-256 (Ethereum-compatible)"
     },
@@ -2612,6 +3248,21 @@ var init_hash = __esm(() => {
       compute: (data) => sha256(data),
       outputLen: 32,
       description: "SHA-256"
+    },
+    twox64: {
+      compute: (data) => twox(data, 64),
+      outputLen: 8,
+      description: "XXH64 with seed 0 (Substrate twox64)"
+    },
+    twox128: {
+      compute: (data) => twox(data, 128),
+      outputLen: 16,
+      description: "XXH64 with seeds 0,1 (Substrate twox128, pallet/storage prefix)"
+    },
+    twox256: {
+      compute: (data) => twox(data, 256),
+      outputLen: 32,
+      description: "XXH64 with seeds 0,1,2,3 (Substrate twox256)"
     }
   };
 });
@@ -2742,11 +3393,8 @@ async function generateCompletions(currentWord, precedingWords) {
   if (firstArg === "hash") {
     return filterPrefix(getAlgorithmNames(), currentWord);
   }
-  if (firstArg === "parachain") {
-    if (prevWord === "--type") {
-      return filterPrefix(["child", "sibling"], currentWord);
-    }
-    return [];
+  if (firstArg === "account" && prevWord === "--parachain-type") {
+    return filterPrefix(["child", "sibling"], currentWord);
   }
   return completeDotpath(currentWord, config, knownChains, precedingWords);
 }
@@ -2789,6 +3437,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
     if (category === "extensions") {
       return completeExtensionsCategory(first, numComplete, endsWithDot, currentWord, config, chainFromFlag);
     }
+    if (category === "rpc") {
+      return completeRpcCategory(first, numComplete, endsWithDot, currentWord, chainFromFlag);
+    }
     if (numComplete === 1 && endsWithDot) {
       const chainName = chainFromFlag;
       if (!chainName)
@@ -2848,6 +3499,9 @@ async function completeDotpath(currentWord, config, knownChains, precedingWords)
       if (category === "extensions") {
         return completeExtensionsCategory(`${first}.${completeSegments[1]}`, numComplete - 1, endsWithDot, currentWord, config, chainName);
       }
+      if (category === "rpc") {
+        return completeRpcCategory(`${first}.${completeSegments[1]}`, numComplete - 1, endsWithDot, currentWord, chainName);
+      }
       const pallets = await loadPallets(config, chainName);
       if (!pallets)
         return [];
@@ -2921,6 +3575,24 @@ async function completeExtensionsCategory(prefix, numComplete, endsWithDot, curr
   }
   return [];
 }
+async function completeRpcCategory(prefix, numComplete, endsWithDot, currentWord, chainNameOverride) {
+  let names;
+  if (chainNameOverride) {
+    const cached = await loadRpcMethods(chainNameOverride);
+    names = cached?.methods ?? Object.keys(RPC_REGISTRY);
+  } else {
+    names = Object.keys(RPC_REGISTRY);
+  }
+  if (numComplete === 1 && endsWithDot) {
+    const candidates = names.map((n) => `${prefix}.${n}`);
+    return filterPrefix(candidates, currentWord.slice(0, -1));
+  }
+  if (numComplete === 1 && !endsWithDot) {
+    const candidates = names.map((n) => `${prefix}.${n}`);
+    return filterPrefix(candidates, currentWord);
+  }
+  return [];
+}
 var CATEGORIES2, CATEGORY_ALIASES2, NAMED_COMMANDS, CHAIN_SUBCOMMANDS, ACCOUNT_SUBCOMMANDS, GLOBAL_OPTIONS, TX_OPTIONS, QUERY_OPTIONS;
 var init_complete = __esm(() => {
   init_accounts_store();
@@ -2928,7 +3600,17 @@ var init_complete = __esm(() => {
   init_accounts();
   init_hash();
   init_metadata();
-  CATEGORIES2 = ["query", "tx", "const", "events", "errors", "apis", "extensions"];
+  init_rpc_registry();
+  CATEGORIES2 = [
+    "query",
+    "tx",
+    "const",
+    "events",
+    "errors",
+    "apis",
+    "extensions",
+    "rpc"
+  ];
   CATEGORY_ALIASES2 = {
     query: "query",
     tx: "tx",
@@ -2943,9 +3625,10 @@ var init_complete = __esm(() => {
     api: "apis",
     extensions: "extensions",
     extension: "extensions",
-    ext: "extensions"
+    ext: "extensions",
+    rpc: "rpc"
   };
-  NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "parachain", "completions"];
+  NAMED_COMMANDS = ["chain", "account", "inspect", "hash", "sign", "completions"];
   CHAIN_SUBCOMMANDS = ["add", "info", "list", "remove", "update"];
   ACCOUNT_SUBCOMMANDS = [
     "add",
@@ -2977,23 +3660,154 @@ var init_complete = __esm(() => {
 // src/cli.ts
 import cac from "cac";
 // package.json
-var version = "1.17.0";
+var version = "1.19.0";
 
 // src/commands/account.ts
 init_accounts_store();
 init_accounts();
-init_output();
 import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { hexToBytes as nobleHexToBytes } 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";
+var ETH_DERIVED_SUFFIX_BYTE = 238;
+var H160_LEN = 20;
+var ACCOUNT_ID_LEN = 32;
+function hasEthDerivedSuffix(accountId) {
+  if (accountId.length !== ACCOUNT_ID_LEN)
+    return false;
+  for (let i = H160_LEN;i < ACCOUNT_ID_LEN; i++) {
+    if (accountId[i] !== ETH_DERIVED_SUFFIX_BYTE)
+      return false;
+  }
+  return true;
+}
+function accountIdToH160(accountId) {
+  if (accountId.length !== ACCOUNT_ID_LEN) {
+    throw new Error(`accountIdToH160 expects 32 bytes, got ${accountId.length}`);
+  }
+  if (hasEthDerivedSuffix(accountId)) {
+    return accountId.slice(0, H160_LEN);
+  }
+  return keccak_256(accountId).slice(ACCOUNT_ID_LEN - H160_LEN);
+}
+function h160ToFallbackAccountId(h160) {
+  if (h160.length !== H160_LEN) {
+    throw new Error(`h160ToFallbackAccountId expects 20 bytes, got ${h160.length}`);
+  }
+  const out = new Uint8Array(ACCOUNT_ID_LEN);
+  out.set(h160, 0);
+  out.fill(ETH_DERIVED_SUFFIX_BYTE, H160_LEN);
+  return out;
+}
+function toEip55(h160) {
+  if (h160.length !== H160_LEN) {
+    throw new Error(`toEip55 expects 20 bytes, got ${h160.length}`);
+  }
+  const lowerHex = bytesToHex2(h160);
+  const hashBytes = keccak_256(new TextEncoder().encode(lowerHex));
+  let out = "0x";
+  for (let i = 0;i < lowerHex.length; i++) {
+    const c = lowerHex[i];
+    const nibble = i % 2 === 0 ? hashBytes[i >> 1] >> 4 : hashBytes[i >> 1] & 15;
+    out += nibble >= 8 ? c.toUpperCase() : c;
+  }
+  return out;
+}
+function isH160Hex(input) {
+  return /^0x[0-9a-fA-F]{40}$/.test(input);
+}
+function h160FromHex(input) {
+  if (!isH160Hex(input)) {
+    throw new Error(`Not a valid 0x-prefixed 20-byte hex string: ${input}`);
+  }
+  return hexToBytes(input.slice(2));
+}
+
+// src/commands/account.ts
+init_output();
+
+// src/core/pallet.ts
+init_errors();
+var MODL_PREFIX = new Uint8Array([109, 111, 100, 108]);
+var PALLET_ID_BYTES = 8;
+function derivePalletAccount(palletId) {
+  if (palletId.length !== PALLET_ID_BYTES) {
+    throw new CliError(`PalletId must be exactly ${PALLET_ID_BYTES} bytes (got ${palletId.length}).`);
+  }
+  const result = new Uint8Array(32);
+  result.set(MODL_PREFIX, 0);
+  result.set(palletId, 4);
+  return result;
+}
+function parsePalletId(input) {
+  if (input.startsWith("0x") || input.startsWith("0X")) {
+    const hex = input.slice(2);
+    if (hex.length !== PALLET_ID_BYTES * 2) {
+      throw new CliError(`Invalid PalletId hex "${input}". Must be 0x followed by exactly ${PALLET_ID_BYTES * 2} hex characters.`);
+    }
+    if (!/^[0-9a-fA-F]+$/.test(hex)) {
+      throw new CliError(`Invalid PalletId hex "${input}". Contains non-hex characters.`);
+    }
+    const bytes2 = new Uint8Array(PALLET_ID_BYTES);
+    for (let i = 0;i < PALLET_ID_BYTES; i++) {
+      bytes2[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes2;
+  }
+  if (input.length !== PALLET_ID_BYTES) {
+    throw new CliError(`Invalid PalletId "${input}". Must be ${PALLET_ID_BYTES} ASCII characters or 0x-prefixed hex.`);
+  }
+  const bytes = new Uint8Array(PALLET_ID_BYTES);
+  for (let i = 0;i < PALLET_ID_BYTES; i++) {
+    const code = input.charCodeAt(i);
+    if (code > 127) {
+      throw new CliError(`Invalid PalletId "${input}". ASCII form must contain only ASCII bytes.`);
+    }
+    bytes[i] = code;
+  }
+  return bytes;
+}
+function formatPalletId(palletId) {
+  const allPrintable = palletId.every((b) => b >= 32 && b <= 126);
+  if (allPrintable) {
+    return Array.from(palletId, (b) => String.fromCharCode(b)).join("");
+  }
+  return `0x${Array.from(palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/core/parachain.ts
+var SOVEREIGN_ACCOUNT_TYPES = ["child", "sibling"];
+var PREFIXES = {
+  child: new Uint8Array([112, 97, 114, 97]),
+  sibling: new Uint8Array([115, 105, 98, 108])
+};
+function deriveSovereignAccount(paraId, type) {
+  const result = new Uint8Array(32);
+  result.set(PREFIXES[type], 0);
+  new DataView(result.buffer).setUint32(4, paraId, true);
+  return result;
+}
+function isValidParaId(value) {
+  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+
+// src/commands/account.ts
 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> --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)
   $ dot account create|new <name> [--path <derivation>]              Create a new account
   $ dot account import <file>                                        Batch-import accounts from a file
   $ dot account export [names...]                                    Export accounts to stdout
   $ dot account derive <source> <new-name> --path <derivation>       Derive a child account
   $ dot account inspect <input> [--prefix <N>] [--show-secret]       Inspect an account/address/key
+  $ dot account inspect --pallet-id <id> [--prefix <N>]              Derive a pallet sovereign (no save — script-friendly)
+  $ dot account inspect --parachain <id> --parachain-type <t>        Derive a parachain sovereign (no save — script-friendly)
   $ dot account list                                                 List all accounts
   $ dot account remove|delete <name> [name2] ...                     Remove stored account(s)
 
@@ -3001,6 +3815,10 @@ ${BOLD}Examples:${RESET}
   $ dot account add treasury 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
   $ dot account add treasury --secret "word1 word2 ... word12"
   $ 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
+  $ dot account add People --parachain 1004 --parachain-type child
+  $ dot account add People-Sibling --parachain 1004 --parachain-type sibling
   $ dot account create my-validator
   $ dot account create my-staking --path //staking
   $ dot account create multi --path //polkadot//0/wallet
@@ -3016,6 +3834,8 @@ ${BOLD}Examples:${RESET}
   $ dot account inspect dave --show-secret
   $ dot account inspect 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
   $ dot account inspect 0xd435...a27d --prefix 0
+  $ dot account inspect --pallet-id py/trsry --prefix 0
+  $ dot account inspect --parachain 1004 --parachain-type child
   $ dot account list
   $ dot account remove my-validator stale-key
 
@@ -3024,7 +3844,7 @@ ${YELLOW}Note: Secrets are stored unencrypted in ~/.polkadot/accounts.json.
       Hex seed import (0x...) is not supported via CLI.${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("--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 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) => {
     if (!action) {
       if (process.argv[2] === "accounts")
         return accountList(opts);
@@ -3036,8 +3856,13 @@ function registerAccountCommands(cli) {
       case "create":
         return accountCreate(names[0], opts);
       case "add":
-        if (opts.secret || opts.env)
+        if (opts.secret || opts.env) {
+          const hasDerivation = opts.parachain != null || opts.palletId != null || process.argv.includes("--parachain") || process.argv.includes("--pallet-id") || process.argv.some((a) => a.startsWith("--parachain=") || a.startsWith("--pallet-id="));
+          if (hasDerivation) {
+            throw new Error("Derivation flags (--parachain, --pallet-id) cannot be combined with --secret or --env. A derived sovereign account has no secret.");
+          }
           return accountImport(names[0], opts);
+        }
         return accountAddWatchOnly(names[0], names[1], opts);
       case "import":
         return accountBatchImport(names[0], opts);
@@ -3193,10 +4018,16 @@ async function accountAddWatchOnly(name, address, opts = {}) {
     console.error("Usage: dot account add <name> <ss58-address|0x-public-key>");
     process.exit(1);
   }
-  if (!address) {
+  const sovereignSource = resolveSovereignSource(opts);
+  if (sovereignSource && address) {
+    throw new Error("Cannot combine a positional address with --parachain or --pallet-id. Pass either an address OR a derivation flag, not both.");
+  }
+  if (!sovereignSource && !address) {
     console.error(`Address is required.
 `);
     console.error("Usage: dot account add <name> <ss58-address|0x-public-key>");
+    console.error("       dot account add <name> --parachain <id> --parachain-type <child|sibling>");
+    console.error("       dot account add <name> --pallet-id <8 chars or 0x hex>");
     process.exit(1);
   }
   if (isDevAccount(name)) {
@@ -3207,7 +4038,10 @@ async function accountAddWatchOnly(name, address, opts = {}) {
     throw new Error(`Account "${name}" already exists.`);
   }
   let hexPub;
-  if (isHexPublicKey(address)) {
+  if (sovereignSource) {
+    const accountId = sovereignSource.kind === "parachain" ? deriveSovereignAccount(sovereignSource.paraId, sovereignSource.type) : derivePalletAccount(sovereignSource.palletId);
+    hexPub = publicKeyToHex(accountId);
+  } else if (isHexPublicKey(address)) {
     hexPub = address;
   } else {
     try {
@@ -3217,21 +4051,99 @@ async function accountAddWatchOnly(name, address, opts = {}) {
       throw new Error(`Invalid address "${address}". Expected an SS58 address or 0x-prefixed 32-byte hex public key.`);
     }
   }
+  let persistedSource;
+  if (sovereignSource?.kind === "pallet") {
+    persistedSource = {
+      kind: "pallet",
+      palletId: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+    };
+  } else if (sovereignSource?.kind === "parachain") {
+    persistedSource = {
+      kind: "parachain",
+      paraId: sovereignSource.paraId,
+      type: sovereignSource.type
+    };
+  }
   accountsFile.accounts.push({
     name,
     publicKey: hexPub,
-    derivationPath: ""
+    derivationPath: "",
+    ...persistedSource ? { source: persistedSource } : {}
   });
   await saveAccounts(accountsFile);
   if (isJsonOutput(opts)) {
-    console.log(formatJson({ name, address: toSs58(hexPub), watchOnly: true }));
+    const payload = {
+      name,
+      address: toSs58(hexPub),
+      watchOnly: true
+    };
+    if (sovereignSource?.kind === "parachain") {
+      payload.derivation = {
+        kind: "parachain",
+        paraId: sovereignSource.paraId,
+        type: sovereignSource.type
+      };
+    } else if (sovereignSource?.kind === "pallet") {
+      payload.derivation = {
+        kind: "pallet",
+        palletId: formatPalletId(sovereignSource.palletId),
+        palletIdHex: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+      };
+    }
+    console.log(formatJson(payload));
     return;
   }
   printHeading("Account Added (watch-only)");
   console.log(`  ${BOLD}Name:${RESET}    ${name}`);
   console.log(`  ${BOLD}Address:${RESET} ${toSs58(hexPub)}`);
+  if (sovereignSource?.kind === "parachain") {
+    console.log(`  ${BOLD}Source:${RESET}  parachain ${sovereignSource.paraId} (${sovereignSource.type} sovereign)`);
+  } else if (sovereignSource?.kind === "pallet") {
+    const display = formatPalletId(sovereignSource.palletId);
+    const hex = `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+    console.log(`  ${BOLD}Source:${RESET}  pallet ${display} (${hex})`);
+  }
   console.log();
 }
+function rawArgValue(flag) {
+  const argv = process.argv;
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === flag && i + 1 < argv.length)
+      return argv[i + 1];
+    const prefix = `${flag}=`;
+    if (argv[i]?.startsWith(prefix))
+      return argv[i].slice(prefix.length);
+  }
+  return;
+}
+function resolveSovereignSource(opts) {
+  const rawPalletId = rawArgValue("--pallet-id") ?? opts.palletId;
+  const rawParachain = rawArgValue("--parachain") ?? opts.parachain;
+  if (rawParachain != null && rawPalletId != null) {
+    throw new Error("--parachain and --pallet-id are mutually exclusive. Pass only one derivation flag.");
+  }
+  if (rawParachain != null) {
+    const paraId = Number(rawParachain);
+    if (!isValidParaId(paraId)) {
+      throw new Error(`Invalid parachain ID "${rawParachain}". Must be a non-negative integer (0 to 4294967295).`);
+    }
+    if (!opts.parachainType) {
+      throw new Error("--parachain-type is required when --parachain is given. Use --parachain-type child or --parachain-type sibling.");
+    }
+    const type = opts.parachainType.toLowerCase();
+    if (type !== "child" && type !== "sibling") {
+      throw new Error(`Unknown parachain account type "${opts.parachainType}". Valid types: child, sibling.`);
+    }
+    return { kind: "parachain", paraId, type };
+  }
+  if (rawPalletId != null) {
+    return { kind: "pallet", palletId: parsePalletId(String(rawPalletId)) };
+  }
+  if (opts.parachainType != null) {
+    throw new Error("--parachain-type requires --parachain.");
+  }
+  return;
+}
 async function accountDerive(sourceName, newName, opts) {
   if (!sourceName) {
     console.error(`Source account name is required.
@@ -3315,69 +4227,134 @@ async function accountDerive(sourceName, newName, opts) {
     console.log();
   }
 }
+function resolveAddress(account) {
+  if (isWatchOnly(account)) {
+    return account.publicKey ? toSs58(account.publicKey) : "n/a";
+  }
+  if (account.secret !== undefined && isEnvSecret(account.secret)) {
+    const pubKey = account.publicKey || tryDerivePublicKey(account.secret.env, account.derivationPath) || "";
+    return pubKey ? toSs58(pubKey) : "n/a";
+  }
+  return toSs58(account.publicKey);
+}
+function buildAttributes(account) {
+  const attrs = [];
+  if (account.derivationPath)
+    attrs.push({ label: "path", value: account.derivationPath });
+  if (account.secret !== undefined && isEnvSecret(account.secret)) {
+    attrs.push({ label: "env", value: `$${account.secret.env}` });
+  }
+  if (account.source) {
+    if (account.source.kind === "pallet") {
+      const bytes = parsePalletId(account.source.palletId);
+      attrs.push({
+        label: "pallet-id",
+        value: `${formatPalletId(bytes)} (${account.source.palletId})`
+      });
+    } else {
+      attrs.push({ label: "parachain", value: String(account.source.paraId) });
+      attrs.push({ label: "parachain-type", value: account.source.type });
+    }
+  }
+  return attrs;
+}
+function buildRow(account) {
+  return {
+    account,
+    kind: classifyAccount(account),
+    address: resolveAddress(account),
+    attributes: buildAttributes(account)
+  };
+}
+var SECTION_ORDER = [
+  { kind: "signer", title: "Signers" },
+  { kind: "watch-only", title: "Watch-only" },
+  { kind: "pallet", title: "Pallet Sovereigns" },
+  { kind: "parachain", title: "Parachain Sovereigns" }
+];
+function printAccountSection(title, rows) {
+  if (rows.length === 0)
+    return;
+  const nameWidth = Math.max(...rows.map((r) => r.name.length));
+  printHeading(title);
+  for (const row of rows) {
+    const namePad = row.name.padEnd(nameWidth);
+    console.log(`  ${CYAN}${namePad}${RESET}  ${row.address}`);
+    if (row.attributes.length === 0)
+      continue;
+    const labelWidth = Math.max(...row.attributes.map((a) => a.label.length)) + 1;
+    for (let i = 0;i < row.attributes.length; i++) {
+      const isLast = i === row.attributes.length - 1;
+      const connector = isLast ? "└─" : "├─";
+      const labelText = `${row.attributes[i].label}:`.padEnd(labelWidth + 1);
+      console.log(`     ${DIM}${connector}${RESET} ${DIM}${labelText}${RESET}${row.attributes[i].value}`);
+    }
+  }
+}
 async function accountList(opts = {}) {
   const accountsFile = await loadAccounts();
   if (isJsonOutput(opts)) {
     const dev = DEV_NAMES.map((name) => ({
       name: name.charAt(0).toUpperCase() + name.slice(1),
-      address: getDevAddress(name)
+      address: getDevAddress(name),
+      kind: "dev"
     }));
     const stored = accountsFile.accounts.map((account) => {
-      let address;
-      if (isWatchOnly(account)) {
-        address = account.publicKey ? toSs58(account.publicKey) : undefined;
-      } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
-        let pubKey = account.publicKey;
-        if (!pubKey) {
-          pubKey = tryDerivePublicKey(account.secret.env, account.derivationPath) ?? "";
-        }
-        address = pubKey ? toSs58(pubKey) : undefined;
-      } else {
-        address = toSs58(account.publicKey);
-      }
-      return {
+      const kind = classifyAccount(account);
+      const entry = {
         name: account.name,
-        address,
-        derivationPath: account.derivationPath || undefined,
-        watchOnly: isWatchOnly(account),
-        env: account.secret !== undefined && isEnvSecret(account.secret) ? account.secret.env : undefined
+        address: resolveAddress(account),
+        kind,
+        watchOnly: isWatchOnly(account)
       };
+      if (account.derivationPath)
+        entry.derivationPath = account.derivationPath;
+      if (account.secret !== undefined && isEnvSecret(account.secret)) {
+        entry.env = account.secret.env;
+      }
+      if (account.source) {
+        if (account.source.kind === "pallet") {
+          const bytes = parsePalletId(account.source.palletId);
+          entry.source = {
+            kind: "pallet",
+            palletId: formatPalletId(bytes),
+            palletIdHex: account.source.palletId
+          };
+        } else {
+          entry.source = account.source;
+        }
+      }
+      return entry;
     });
     console.log(formatJson({ dev, stored }));
     return;
   }
-  printHeading("Dev Accounts");
-  for (const name of DEV_NAMES) {
-    const display = name.charAt(0).toUpperCase() + name.slice(1);
-    const address = getDevAddress(name);
-    printItem(display, address);
+  const devRows = DEV_NAMES.map((name) => ({
+    name: name.charAt(0).toUpperCase() + name.slice(1),
+    address: getDevAddress(name),
+    attributes: []
+  }));
+  printAccountSection("Dev Accounts", devRows);
+  const buckets = new Map;
+  for (const account of accountsFile.accounts) {
+    const row = buildRow(account);
+    const arr = buckets.get(row.kind) ?? [];
+    arr.push(row);
+    buckets.set(row.kind, arr);
+  }
+  for (const { kind, title } of SECTION_ORDER) {
+    const rows = buckets.get(kind);
+    if (!rows || rows.length === 0)
+      continue;
+    printAccountSection(title, rows.map((r) => ({
+      name: r.account.name,
+      address: r.address,
+      attributes: r.attributes
+    })));
   }
-  if (accountsFile.accounts.length > 0) {
-    printHeading("Stored Accounts");
-    for (const account of accountsFile.accounts) {
-      let displayName = account.name;
-      if (account.derivationPath) {
-        displayName += ` (${account.derivationPath})`;
-      }
-      let address;
-      if (isWatchOnly(account)) {
-        displayName += " (watch-only)";
-        address = account.publicKey ? toSs58(account.publicKey) : "n/a";
-      } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
-        displayName += ` (env: ${account.secret.env})`;
-        let pubKey = account.publicKey;
-        if (!pubKey) {
-          pubKey = tryDerivePublicKey(account.secret.env, account.derivationPath) ?? "";
-        }
-        address = pubKey ? toSs58(pubKey) : "n/a";
-      } else {
-        address = toSs58(account.publicKey);
-      }
-      printItem(displayName, address);
-    }
-  } else {
+  if (accountsFile.accounts.length === 0) {
     printHeading("Stored Accounts");
-    console.log("  (none)");
+    console.log(`  ${DIM}(none)${RESET}`);
   }
   console.log();
 }
@@ -3425,10 +4402,20 @@ async function accountRemove(names, opts = {}) {
   }
 }
 async function accountInspect(input, opts) {
-  if (!input) {
+  const sovereignSource = resolveSovereignSource({
+    parachain: opts.parachain,
+    parachainType: opts.parachainType,
+    palletId: opts.palletId
+  });
+  if (sovereignSource && input) {
+    throw new Error("Cannot combine a positional input with --parachain or --pallet-id. Pass either an existing-account input OR a derivation flag, not both.");
+  }
+  if (!sovereignSource && !input) {
     console.error(`Input is required.
 `);
     console.error("Usage: dot account inspect <name|ss58-address|0x-public-key> [--prefix <N>]");
+    console.error("       dot account inspect --pallet-id <id> [--prefix <N>]");
+    console.error("       dot account inspect --parachain <id> --parachain-type <child|sibling> [--prefix <N>]");
     process.exit(1);
   }
   const prefix = opts.prefix != null ? Number(opts.prefix) : 42;
@@ -3440,11 +4427,33 @@ async function accountInspect(input, opts) {
   let publicKeyHex;
   let bandersnatch;
   let hasSecret = false;
-  if (isDevAccount(input)) {
+  let storedAccount;
+  let isDev = false;
+  let isH160Fallback = false;
+  let virtualSource;
+  if (sovereignSource) {
+    if (sovereignSource.kind === "pallet") {
+      const accountId = derivePalletAccount(sovereignSource.palletId);
+      publicKeyHex = publicKeyToHex(accountId);
+      virtualSource = {
+        kind: "pallet",
+        palletIdHex: `0x${Array.from(sovereignSource.palletId, (b) => b.toString(16).padStart(2, "0")).join("")}`
+      };
+    } else {
+      const accountId = deriveSovereignAccount(sovereignSource.paraId, sovereignSource.type);
+      publicKeyHex = publicKeyToHex(accountId);
+      virtualSource = {
+        kind: "parachain",
+        paraId: sovereignSource.paraId,
+        type: sovereignSource.type
+      };
+    }
+  } else if (isDevAccount(input)) {
     name = input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
     const devAddr = getDevAddress(input);
     publicKeyHex = publicKeyToHex(fromSs58(devAddr));
     hasSecret = true;
+    isDev = true;
   } else {
     const accountsFile = await loadAccounts();
     const account = findAccount(accountsFile, input);
@@ -3452,6 +4461,7 @@ async function accountInspect(input, opts) {
       name = account.name;
       bandersnatch = account.bandersnatch;
       hasSecret = account.secret !== undefined;
+      storedAccount = account;
       if (account.publicKey) {
         publicKeyHex = account.publicKey;
       } else if (account.secret !== undefined && isEnvSecret(account.secret)) {
@@ -3467,17 +4477,22 @@ async function accountInspect(input, opts) {
       }
     } else if (isHexPublicKey(input)) {
       publicKeyHex = input;
+    } else if (isH160Hex(input)) {
+      const fallback = h160ToFallbackAccountId(h160FromHex(input));
+      publicKeyHex = publicKeyToHex(fallback);
+      isH160Fallback = true;
     } else {
       try {
         const decoded = fromSs58(input);
         publicKeyHex = publicKeyToHex(decoded);
       } catch {
-        console.error(`Cannot identify "${input}" as an account name, SS58 address, or hex public key.`);
+        console.error(`Cannot identify "${input}" as an account name, SS58 address, hex public key, or H160.`);
         process.exit(1);
       }
     }
   }
   const ss58 = toSs58(publicKeyHex, prefix);
+  const h160Hex = toEip55(accountIdToH160(nobleHexToBytes(publicKeyHex.slice(2))));
   let privateKeyHex;
   if (opts.showSecret) {
     if (!name) {
@@ -3495,10 +4510,81 @@ async function accountInspect(input, opts) {
       process.exit(1);
     }
   }
+  let kindLabel;
+  let sourceLine;
+  let derivationLine;
+  let envLine;
+  if (virtualSource?.kind === "pallet") {
+    kindLabel = "pallet sovereign";
+    const bytes = parsePalletId(virtualSource.palletIdHex);
+    sourceLine = `PalletId ${formatPalletId(bytes)} (${virtualSource.palletIdHex})`;
+  } else if (virtualSource?.kind === "parachain") {
+    kindLabel = `parachain sovereign (${virtualSource.type})`;
+    sourceLine = `parachain ${virtualSource.paraId}`;
+  } else if (isDev) {
+    kindLabel = "dev";
+  } else if (isH160Fallback) {
+    kindLabel = "revive H160 fallback";
+  } else if (storedAccount) {
+    const k = classifyAccount(storedAccount);
+    if (k === "pallet" && storedAccount.source?.kind === "pallet") {
+      kindLabel = "pallet sovereign";
+      const bytes = parsePalletId(storedAccount.source.palletId);
+      sourceLine = `PalletId ${formatPalletId(bytes)} (${storedAccount.source.palletId})`;
+    } else if (k === "parachain" && storedAccount.source?.kind === "parachain") {
+      kindLabel = `parachain sovereign (${storedAccount.source.type})`;
+      sourceLine = `parachain ${storedAccount.source.paraId}`;
+    } else if (k === "signer") {
+      kindLabel = "signer";
+    } else {
+      kindLabel = "watch-only";
+    }
+    if (storedAccount.derivationPath)
+      derivationLine = storedAccount.derivationPath;
+    if (storedAccount.secret !== undefined && isEnvSecret(storedAccount.secret)) {
+      envLine = `$${storedAccount.secret.env}`;
+    }
+  }
   if (isJsonOutput(opts)) {
-    const result = { publicKey: publicKeyHex, ss58, prefix };
+    const result = {
+      publicKey: publicKeyHex,
+      ss58,
+      h160: h160Hex,
+      prefix
+    };
     if (name)
       result.name = name;
+    if (kindLabel)
+      result.kind = kindLabel;
+    if (virtualSource?.kind === "pallet") {
+      const bytes = parsePalletId(virtualSource.palletIdHex);
+      result.source = {
+        kind: "pallet",
+        palletId: formatPalletId(bytes),
+        palletIdHex: virtualSource.palletIdHex
+      };
+    } else if (virtualSource?.kind === "parachain") {
+      result.source = {
+        kind: "parachain",
+        paraId: virtualSource.paraId,
+        type: virtualSource.type
+      };
+    } else if (storedAccount?.source) {
+      if (storedAccount.source.kind === "pallet") {
+        const bytes = parsePalletId(storedAccount.source.palletId);
+        result.source = {
+          kind: "pallet",
+          palletId: formatPalletId(bytes),
+          palletIdHex: storedAccount.source.palletId
+        };
+      } else {
+        result.source = storedAccount.source;
+      }
+    }
+    if (derivationLine)
+      result.derivationPath = derivationLine;
+    if (envLine)
+      result.env = envLine.replace(/^\$/, "");
     if (bandersnatch && Object.keys(bandersnatch).length > 0)
       result.bandersnatch = bandersnatch;
     if (privateKeyHex)
@@ -3508,8 +4594,17 @@ async function accountInspect(input, opts) {
     printHeading("Account Info");
     if (name)
       console.log(`  ${BOLD}Name:${RESET}        ${name}`);
+    if (kindLabel)
+      console.log(`  ${BOLD}Kind:${RESET}        ${kindLabel}`);
     console.log(`  ${BOLD}Public Key:${RESET}  ${publicKeyHex}`);
     console.log(`  ${BOLD}SS58:${RESET}        ${ss58}`);
+    console.log(`  ${BOLD}H160:${RESET}        ${h160Hex}`);
+    if (sourceLine)
+      console.log(`  ${BOLD}Source:${RESET}      ${sourceLine}`);
+    if (derivationLine)
+      console.log(`  ${BOLD}Derivation:${RESET}  ${derivationLine}`);
+    if (envLine)
+      console.log(`  ${BOLD}Env:${RESET}         ${envLine}`);
     if (bandersnatch && Object.keys(bandersnatch).length > 0) {
       const entries = Object.entries(bandersnatch);
       for (let i = 0;i < entries.length; i++) {
@@ -3777,8 +4872,10 @@ async function handleApis2(target, args, opts) {
       typeof opts.parsedArgs === "object" ? JSON.stringify(opts.parsedArgs) : String(opts.parsedArgs)
     ];
     const parsedArgs = await parseRuntimeApiArgs2(meta, method, effectiveArgs);
+    const atArg = parseAtForRead(opts.at);
+    const pullOpts = atArg !== undefined ? [{ at: atArg }] : [];
     const unsafeApi = clientHandle.client.getUnsafeApi();
-    const result = await unsafeApi.apis[api.name][method.name](...parsedArgs);
+    const result = await withBlockAvailabilityHint(opts.at, () => unsafeApi.apis[api.name][method.name](...parsedArgs, ...pullOpts));
     const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     printResult(result, format);
   } finally {
@@ -3813,6 +4910,53 @@ init_client();
 init_metadata();
 init_output();
 import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+
+// src/core/rpc.ts
+init_errors();
+import { createClient as createSubstrateClient } from "@polkadot-api/substrate-client";
+import { getWsProvider as getWsProvider2 } from "polkadot-api/ws";
+function suppressProviderNoise2() {
+  const origError = console.error;
+  console.error = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("Unable to connect"))
+      return;
+    origError(...args);
+  };
+  return () => {
+    console.error = origError;
+  };
+}
+async function rpcRequest(rpcUrl, method, params, timeoutMs = 30000) {
+  const restoreConsole = suppressProviderNoise2();
+  const provider = getWsProvider2(rpcUrl, { timeout: 1e4 });
+  const client = createSubstrateClient(provider);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await client.request(method, params, controller.signal);
+  } catch (err) {
+    if (err instanceof Error && /Unable to connect/i.test(err.message)) {
+      throw new ConnectionError(`Could not reach RPC ${Array.isArray(rpcUrl) ? rpcUrl.join(", ") : rpcUrl}: ${err.message}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+    try {
+      client.destroy();
+    } catch {}
+    setTimeout(restoreConsole, 100);
+  }
+}
+async function fetchRpcMethods(rpcUrl) {
+  const result = await rpcRequest(rpcUrl, "rpc_methods", []);
+  if (!result || !Array.isArray(result.methods)) {
+    throw new ConnectionError("Node returned an unexpected response for rpc_methods (no methods array).");
+  }
+  return { methods: result.methods, version: result.version ?? 1 };
+}
+
+// src/commands/chain.ts
+init_rpc_registry();
 var CHAIN_HELP = `
 ${BOLD}Usage:${RESET}
   $ dot chain add <name> --rpc <url>    Add a chain via WebSocket RPC
@@ -3881,6 +5025,18 @@ function registerChainCommands(cli) {
     }
   });
 }
+async function refreshRpcMethods(chainName, rpcUrl, silent = false) {
+  try {
+    const { methods, version: version2 } = await fetchRpcMethods(rpcUrl);
+    await saveRpcMethods(chainName, methods, version2);
+  } catch (err) {
+    if (!silent) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`${YELLOW}Warning:${RESET} could not fetch rpc_methods — ${msg}
+`);
+    }
+  }
+}
 async function chainAdd(name, opts) {
   if (!name) {
     console.error(`Chain name is required.
@@ -3909,6 +5065,7 @@ async function chainAdd(name, opts) {
     process.stderr.write(`Fetching metadata...
 `);
     await fetchMetadataFromChain(clientHandle, name);
+    await refreshRpcMethods(name, opts.rpc);
     if (opts.relay) {
       const config2 = await loadConfig();
       const relayResolved = findChainName(config2, opts.relay);
@@ -4049,6 +5206,12 @@ async function chainInfo(name, opts = {}) {
   const rpcs = Array.isArray(chain.rpc) ? chain.rpc : [chain.rpc];
   const parachains = Object.entries(config.chains).filter(([, c]) => c.relay === resolved).map(([n, c]) => ({ name: n, parachainId: c.parachainId }));
   const fingerprint = await loadMetadataFingerprint(resolved);
+  const rpcCache = await loadRpcMethods(resolved);
+  const rpcSummary = rpcCache ? {
+    count: rpcCache.methods.length,
+    fetchedAt: rpcCache.fetchedAt,
+    byFamily: countByFamily(rpcCache.methods)
+  } : null;
   if (isJsonOutput(opts)) {
     console.log(formatJson({
       name: resolved,
@@ -4060,7 +5223,8 @@ async function chainInfo(name, opts = {}) {
         specName: fingerprint.specName,
         specVersion: fingerprint.specVersion,
         fetchedAt: fingerprint.fetchedAt
-      } : null
+      } : null,
+      rpcMethods: rpcSummary
     }));
     return;
   }
@@ -4088,6 +5252,22 @@ async function chainInfo(name, opts = {}) {
   } else {
     console.log(`    ${DIM}not cached — run \`dot chain update ${resolved}\`${RESET}`);
   }
+  console.log(`  ${CYAN}rpc methods:${RESET}`);
+  if (rpcSummary) {
+    const families = Object.entries(rpcSummary.byFamily).map(([f, n]) => `${f}: ${n}`).join(", ");
+    console.log(`    ${rpcSummary.count} ${DIM}(${families})${RESET}`);
+    console.log(`    ${DIM}cached ${rpcSummary.fetchedAt}${RESET}`);
+  } else {
+    console.log(`    ${DIM}not cached — run \`dot chain update ${resolved}\`${RESET}`);
+  }
+}
+function countByFamily(methods) {
+  const counts = {};
+  for (const m of methods) {
+    const family = RPC_REGISTRY[m]?.family ?? inferFamily(m);
+    counts[family] = (counts[family] ?? 0) + 1;
+  }
+  return counts;
 }
 async function chainUpdate(name, opts) {
   const config = await loadConfig();
@@ -4107,6 +5287,7 @@ async function chainUpdate(name, opts) {
     process.stderr.write(`Fetching metadata...
 `);
     await fetchMetadataFromChain(clientHandle, chainName);
+    await refreshRpcMethods(chainName, opts.rpc ?? chainConfig.rpc);
     if (isJsonOutput(opts)) {
       console.log(formatJson({ action: "updated", chain: chainName }));
     } else {
@@ -4136,6 +5317,7 @@ async function updateChainsMetadata(config, chainNames) {
     const clientHandle = await createChainClient(chainName, chainConfig);
     try {
       await fetchMetadataFromChain(clientHandle, chainName);
+      await refreshRpcMethods(chainName, chainConfig.rpc, true);
     } finally {
       clientHandle.destroy();
     }
@@ -5687,24 +6869,6 @@ function registerMetadataCommand(cli) {
 // src/commands/parachain.ts
 init_accounts();
 init_output();
-
-// src/core/parachain.ts
-var SOVEREIGN_ACCOUNT_TYPES = ["child", "sibling"];
-var PREFIXES = {
-  child: new Uint8Array([112, 97, 114, 97]),
-  sibling: new Uint8Array([115, 105, 98, 108])
-};
-function deriveSovereignAccount(paraId, type) {
-  const result = new Uint8Array(32);
-  result.set(PREFIXES[type], 0);
-  new DataView(result.buffer).setUint32(4, paraId, true);
-  return result;
-}
-function isValidParaId(value) {
-  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
-}
-
-// src/commands/parachain.ts
 init_errors();
 function printParachainHelp() {
   console.log(`${BOLD}Usage:${RESET} dot parachain <paraId> [options]
@@ -5734,6 +6898,7 @@ function validateType(type) {
 }
 function registerParachainCommand(cli) {
   cli.command("parachain [paraId]", "Derive parachain sovereign accounts").option("--type <type>", "Account type: child, sibling (default: both)").option("--prefix <number>", "SS58 prefix for address encoding (default: 42)").action(async (paraIdStr, opts) => {
+    console.error("Warning: `dot parachain` is deprecated; use `dot account inspect --parachain <id> --parachain-type <child|sibling>` instead. Will be removed in a future release.");
     if (!paraIdStr) {
       printParachainHelp();
       return;
@@ -5880,6 +7045,8 @@ async function handleQuery(target, keys, opts) {
       typeof opts.parsedArgs === "object" ? JSON.stringify(opts.parsedArgs) : String(opts.parsedArgs)
     ];
     const parsedKeys = await parseStorageKeys(meta, palletInfo.name, storageItem, effectiveKeys);
+    const atArg = parseAtForRead(opts.at);
+    const pullOpts = atArg !== undefined ? [{ at: atArg }] : [];
     const format = isJsonOutput(opts) ? "json" : opts.output ?? "pretty";
     const expectedLen = storageItem.type === "map" && storageItem.keyTypeId != null ? meta.builder.buildStorage(palletInfo.name, storageItem.name).len : 0;
     if (storageItem.type === "map" && parsedKeys.length < expectedLen) {
@@ -5889,7 +7056,7 @@ async function handleQuery(target, keys, opts) {
         console.log(`${DIM}Hint: use --dump to fetch all entries${RESET}`);
         return;
       }
-      const entries = await withStalenessSuggestion(chainName, clientHandle, () => storageApi.getEntries(...parsedKeys));
+      const entries = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => storageApi.getEntries(...parsedKeys, ...pullOpts)));
       const rows = entries.map((e) => ({
         keys: e.keyArgs,
         value: e.value
@@ -5898,7 +7065,7 @@ async function handleQuery(target, keys, opts) {
       await writeStdout(`${text}
 `);
     } else {
-      const result = await withStalenessSuggestion(chainName, clientHandle, () => storageApi.getValue(...parsedKeys));
+      const result = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => storageApi.getValue(...parsedKeys, ...pullOpts)));
       const text = format === "json" ? formatJson(result) : formatPretty(result);
       await writeStdout(`${text}
 `);
@@ -5947,6 +7114,168 @@ async function parseStorageKeys(meta, palletName2, storageItem, args) {
   return Promise.all(args.map((arg) => parseTypedArg(meta, keyEntry, arg)));
 }
 
+// src/commands/rpc.ts
+init_store();
+init_output();
+init_rpc_registry();
+init_errors();
+var FAMILY_ORDER = [
+  "system",
+  "chain",
+  "state",
+  "author",
+  "payment",
+  "babe",
+  "grandpa",
+  "beefy",
+  "mmr",
+  "offchain",
+  "dev",
+  "spec",
+  "chainHead",
+  "chainSpec",
+  "transaction",
+  "archive",
+  "other"
+];
+async function getMethodList(chainName, rpcUrl, refresh) {
+  if (!refresh) {
+    const cached = await loadRpcMethods(chainName);
+    if (cached) {
+      return { methods: cached.methods, version: cached.version, fromCache: true };
+    }
+  }
+  const fresh = await fetchRpcMethods(rpcUrl);
+  await saveRpcMethods(chainName, fresh.methods, fresh.version);
+  return { methods: fresh.methods, version: fresh.version, fromCache: false };
+}
+function groupByFamily(methods) {
+  const groups = new Map;
+  for (const m of methods) {
+    const family = RPC_REGISTRY[m]?.family ?? inferFamily(m);
+    const list = groups.get(family) ?? [];
+    list.push(m);
+    groups.set(family, list);
+  }
+  for (const list of groups.values())
+    list.sort();
+  return groups;
+}
+function formatArgs(info) {
+  if (info.args.length === 0)
+    return "(no args)";
+  return info.args.map((a) => `<${a.name}: ${a.type}${a.optional ? "?" : ""}>`).join(" ");
+}
+function printMethodHelp(method, info) {
+  console.log();
+  console.log(`${BOLD}${method}${RESET}`);
+  if (info) {
+    if (info.dangerous) {
+      console.log(`  ${YELLOW}⚠️  WRITE / state-changing${RESET}`);
+    }
+    if (info.subscription) {
+      console.log(`  ${DIM}subscription — not callable as a one-shot${RESET}`);
+    }
+    console.log(`  ${info.description}`);
+    console.log();
+    console.log(`  ${DIM}Family:${RESET} ${info.family}`);
+    console.log(`  ${DIM}Args:${RESET}   ${formatArgs(info)}`);
+    if (info.args.some((a) => a.description)) {
+      console.log();
+      for (const a of info.args) {
+        if (a.description) {
+          console.log(`    ${CYAN}${a.name}${RESET}  ${DIM}${a.description}${RESET}`);
+        }
+      }
+    }
+  } else {
+    console.log(`  ${DIM}No curated metadata. Args are passed through as raw JSON-RPC params.${RESET}`);
+    console.log(`  ${DIM}Family:${RESET} ${inferFamily(method)} (inferred)`);
+  }
+  console.log();
+}
+async function listMethods(chainName, rpcUrl, opts) {
+  const { methods, version: version2, fromCache } = await getMethodList(chainName, rpcUrl, opts.refresh ?? false);
+  if (isJsonOutput(opts)) {
+    console.log(formatJson({
+      chain: chainName,
+      version: version2,
+      fromCache,
+      methods: methods.map((m) => {
+        const info = RPC_REGISTRY[m];
+        return {
+          method: m,
+          family: info?.family ?? inferFamily(m),
+          description: info?.description,
+          dangerous: info?.dangerous ?? false,
+          subscription: info?.subscription ?? false
+        };
+      })
+    }));
+    return;
+  }
+  printHeading(`RPC methods on ${chainName} (${methods.length})`);
+  const groups = groupByFamily(methods);
+  for (const family of FAMILY_ORDER) {
+    const list = groups.get(family);
+    if (!list || list.length === 0)
+      continue;
+    console.log(`${BOLD}${family}${RESET} ${DIM}(${list.length})${RESET}`);
+    for (const m of list) {
+      const info = RPC_REGISTRY[m];
+      const tags = [];
+      if (info?.dangerous)
+        tags.push(`${YELLOW}⚠ write${RESET}`);
+      if (info?.subscription)
+        tags.push(`${DIM}sub${RESET}`);
+      const suffix = tags.length > 0 ? ` ${tags.join(" ")}` : "";
+      const desc = info?.description ? `  ${DIM}${info.description}${RESET}` : "";
+      console.log(`  ${CYAN}${m}${RESET}${suffix}${desc}`);
+    }
+    console.log();
+  }
+  if (!fromCache) {
+    console.log(`${DIM}(fetched from node — cached for next run)${RESET}`);
+  }
+}
+async function handleRpc(method, args, opts) {
+  const config = await loadConfig();
+  const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
+  const rpcUrl = opts.rpc ?? chainConfig.rpc;
+  if (!rpcUrl) {
+    throw new CliError(`No RPC endpoint for chain "${chainName}". Pass --rpc or run \`dot chain add ${chainName} --rpc <url>\`.`);
+  }
+  if (!method) {
+    await listMethods(chainName, rpcUrl, opts);
+    return;
+  }
+  const info = RPC_REGISTRY[method];
+  if (opts.help) {
+    printMethodHelp(method, info);
+    return;
+  }
+  const { methods: knownMethods } = await getMethodList(chainName, rpcUrl, opts.refresh ?? false);
+  if (!knownMethods.includes(method)) {
+    const hint = suggestMessage("method", method, knownMethods);
+    throw new CliError(`Method "${method}" is not exposed by the node for "${chainName}".${hint ? ` ${hint}` : ""} ` + `Run \`dot ${chainName}.rpc --refresh\` if the node has been upgraded.`);
+  }
+  if (info?.subscription) {
+    throw new CliError(`"${method}" is a subscription method (requires a follow session) and is not callable as a one-shot. ` + `Use a long-running client for streaming RPC.`);
+  }
+  if (!info && /(_subscribe|_unsubscribe)/.test(method)) {
+    throw new CliError(`"${method}" looks like a subscription/unsubscription method and isn't supported as a one-shot. ` + `Pass --help to see what we know about it.`);
+  }
+  if (info) {
+    const required = info.args.filter((a) => !a.optional).length;
+    if (args.length < required) {
+      throw new CliError(`"${method}" expects at least ${required} argument(s) (${formatArgs(info)}); got ${args.length}.`);
+    }
+  }
+  const params = args.map(parseValue);
+  const result = await rpcRequest(rpcUrl, method, params);
+  printResult(result, isJsonOutput(opts) ? "json" : opts.output);
+}
+
 // src/commands/sign.ts
 init_accounts();
 init_hash();
@@ -6360,7 +7689,7 @@ async function handleTx(target, args, opts) {
       let estimatedFees;
       let estimationError;
       try {
-        estimatedFees = String(await withStalenessSuggestion(chainName, clientHandle, () => tx.getEstimatedFees(signer?.publicKey, txOptions)));
+        estimatedFees = String(await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => tx.getEstimatedFees(signer?.publicKey, txOptions))));
       } catch (err) {
         estimationError = err instanceof Error ? err.message : String(err);
       }
@@ -6430,7 +7759,7 @@ async function handleTx(target, args, opts) {
       }
       const observable = clientHandle.client.submitAndWatch(generalTx, at);
       if (isJsonOutput(opts)) {
-        const result3 = await withStalenessSuggestion(chainName, clientHandle, () => watchTransactionJson(observable, waitLevel, { unsigned: true }));
+        const result3 = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => watchTransactionJson(observable, waitLevel, { unsigned: true })));
         const rpcUrl3 = primaryRpc(opts.rpc ?? chainConfig.rpc);
         if (result3.type === "broadcasted") {
           printJsonLine({ event: "broadcasted", txHash: result3.txHash });
@@ -6462,7 +7791,7 @@ async function handleTx(target, args, opts) {
         }
         return;
       }
-      const result2 = await withStalenessSuggestion(chainName, clientHandle, () => watchTransaction(observable, waitLevel, { unsigned: true }));
+      const result2 = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => watchTransaction(observable, waitLevel, { unsigned: true })));
       console.log();
       console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
       console.log(`  ${BOLD}Type:${RESET}   unsigned (bare)`);
@@ -6511,7 +7840,7 @@ async function handleTx(target, args, opts) {
       return;
     }
     if (isJsonOutput(opts)) {
-      const result2 = await withStalenessSuggestion(chainName, clientHandle, () => watchTransactionJson(tx.signSubmitAndWatch(signer, txOptions), waitLevel));
+      const result2 = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => watchTransactionJson(tx.signSubmitAndWatch(signer, txOptions), waitLevel)));
       const rpcUrl2 = primaryRpc(opts.rpc ?? chainConfig.rpc);
       if (result2.type === "broadcasted") {
         printJsonLine({ event: "broadcasted", txHash: result2.txHash });
@@ -6542,7 +7871,7 @@ async function handleTx(target, args, opts) {
       }
       return;
     }
-    const result = await withStalenessSuggestion(chainName, clientHandle, () => watchTransaction(tx.signSubmitAndWatch(signer, txOptions), waitLevel));
+    const result = await withStalenessSuggestion(chainName, clientHandle, () => withBlockAvailabilityHint(opts.at, () => watchTransaction(tx.signSubmitAndWatch(signer, txOptions), waitLevel)));
     console.log();
     console.log(`  ${BOLD}Chain:${RESET}  ${chainName}`);
     console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
@@ -7946,7 +9275,8 @@ var CATEGORY_ALIASES = {
   api: "apis",
   extensions: "extensions",
   extension: "extensions",
-  ext: "extensions"
+  ext: "extensions",
+  rpc: "rpc"
 };
 function matchCategory(segment) {
   return CATEGORY_ALIASES[segment.toLowerCase()];
@@ -7961,7 +9291,7 @@ function parseDotPath(input, knownChains = []) {
       const cat = matchCategory(parts[0]);
       if (cat)
         return { category: cat };
-      throw new Error(`Unknown command "${parts[0]}". Expected a category (query, tx, const, events, errors, apis, extensions) or a named command.`);
+      throw new Error(`Unknown command "${parts[0]}". Expected a category (query, tx, const, events, errors, apis, extensions, rpc) or a named command.`);
     }
     case 2: {
       const cat = matchCategory(parts[0]);
@@ -8016,7 +9346,15 @@ if (process.argv[2] === "__complete") {
     process.exit(0);
   })();
 } else {
-  let collectVarFlags = function(argv) {
+  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) {
     const vars = [];
     for (let i = 0;i < argv.length; i++) {
       if (argv[i] === "--var" && i + 1 < argv.length) {
@@ -8043,6 +9381,7 @@ if (process.argv[2] === "__complete") {
     console.log("  errors    List or inspect pallet errors");
     console.log("  apis      Browse and call runtime APIs");
     console.log("  extensions  List transaction extensions on a chain");
+    console.log("  rpc       Call raw JSON-RPC methods on a node");
     console.log();
     console.log("Examples:");
     console.log("  dot polkadot.query.System.Account <addr>            Query a storage item");
@@ -8055,6 +9394,8 @@ if (process.argv[2] === "__complete") {
     console.log("  dot metadata polkadot                               Dump runtime metadata as JSON");
     console.log("  dot polkadot.extensions                             List transaction extensions");
     console.log("  dot polkadot.extensions.CheckMortality              Inspect one extension");
+    console.log("  dot polkadot.rpc                                    List RPC methods on the node");
+    console.log("  dot polkadot.rpc.system_health                      Call a JSON-RPC method");
     console.log("  dot query.System.Number --chain polkadot            --chain flag form");
     console.log("  dot ./transfer.yaml --from alice                    Run from file (chain in YAML)");
     console.log("  dot tx.0x1f0003... --to-yaml --chain polkadot       Decode hex call to YAML");
@@ -8068,7 +9409,7 @@ if (process.argv[2] === "__complete") {
     console.log("  account            Manage accounts");
     console.log("  hash               Hash utilities");
     console.log("  sign               Sign a message with an account keypair");
-    console.log("  parachain          Derive parachain sovereign accounts");
+    console.log("  parachain          Derive parachain sovereign accounts (deprecated \u2014 use `account inspect --parachain`)");
     console.log("  verifiable         Derive Bandersnatch member key from mnemonic");
     console.log("  completions <sh>   Generate shell completions (zsh, bash, fish)");
     console.log();
@@ -8099,11 +9440,12 @@ if (process.argv[2] === "__complete") {
   registerVerifiableCommands(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 validate against (for tx)').option("--unsigned", "Submit as unsigned/bare transaction (no signer required, for tx)").action(async (dotpath, args, opts) => {
+  }).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) => {
     if (!dotpath) {
       printHelp();
       return;
     }
+    const atRaw = readAtFromArgv(process.argv);
     if (isFilePath(dotpath)) {
       const cliVars = collectVarFlags(process.argv);
       const cmd = await loadCommandFile(dotpath, cliVars);
@@ -8131,7 +9473,7 @@ if (process.argv[2] === "__complete") {
             nonce: opts.nonce,
             tip: opts.tip,
             mortality: opts.mortality,
-            at: opts.at,
+            at: atRaw,
             parsedArgs: cmd.args
           });
           break;
@@ -8139,6 +9481,7 @@ if (process.argv[2] === "__complete") {
           await handleQuery(target2, args, {
             ...handlerOpts2,
             dump: opts.dump,
+            at: atRaw,
             parsedArgs: cmd.args
           });
           break;
@@ -8148,6 +9491,7 @@ if (process.argv[2] === "__complete") {
         case "apis":
           await handleApis2(target2, args, {
             ...handlerOpts2,
+            at: atRaw,
             parsedArgs: cmd.args
           });
           break;
@@ -8162,9 +9506,10 @@ if (process.argv[2] === "__complete") {
     } catch {
       throw new CliError2(`Unknown command "${dotpath}". Run "dot --help" for available commands.`);
     }
+    const isFlatCategory = parsed.category === "rpc" || parsed.category === "extensions";
     if (!parsed.pallet && args.length > 0) {
       parsed.pallet = args.shift();
-      if (!parsed.item && args.length > 0) {
+      if (!isFlatCategory && !parsed.item && args.length > 0) {
         parsed.item = args.shift();
       }
     }
@@ -8185,7 +9530,7 @@ if (process.argv[2] === "__complete") {
     }
     switch (parsed.category) {
       case "query":
-        await handleQuery(target, args, { ...handlerOpts, dump: opts.dump });
+        await handleQuery(target, args, { ...handlerOpts, dump: opts.dump, at: atRaw });
         break;
       case "tx": {
         const txOpts = {
@@ -8202,7 +9547,7 @@ if (process.argv[2] === "__complete") {
           nonce: opts.nonce,
           tip: opts.tip,
           mortality: opts.mortality,
-          at: opts.at
+          at: atRaw
         };
         if (parsed.pallet && /^0x[0-9a-fA-F]+$/.test(parsed.pallet)) {
           await handleTx(parsed.pallet, args, txOpts);
@@ -8221,7 +9566,7 @@ if (process.argv[2] === "__complete") {
         await handleErrors2(target, handlerOpts);
         break;
       case "apis":
-        await handleApis2(target, args, handlerOpts);
+        await handleApis2(target, args, { ...handlerOpts, at: atRaw });
         break;
       case "extensions": {
         if (parsed.item) {
@@ -8231,6 +9576,18 @@ if (process.argv[2] === "__complete") {
         await handleExtensions(parsed.pallet, handlerOpts);
         break;
       }
+      case "rpc": {
+        if (parsed.item) {
+          const suggestion = parsed.chain ? `dot ${parsed.chain}.rpc.${parsed.pallet}` : opts.chain ? `dot rpc.${parsed.pallet} --chain ${opts.chain}` : `dot rpc.${parsed.pallet} --chain <chain>`;
+          throw new CliError2(`RPC methods have no sub-items. Try "${suggestion}".`);
+        }
+        await handleRpc(parsed.pallet, args, {
+          ...handlerOpts,
+          help: cli.options.help,
+          refresh: opts.refresh
+        });
+        break;
+      }
     }
   });
   cli.option("--help, -h", "Display this message");