polkadot-cli 0.2.0 → 0.4.0

package/dist/cli.mjs

@@ -275,6 +275,13 @@ function findPallet(meta, palletName) {
   const pallets = listPallets(meta);
   return pallets.find((p) => p.name.toLowerCase() === palletName.toLowerCase());
 }
+function getSignedExtensions(meta) {
+  const byVersion = meta.unified.extrinsic.signedExtensions;
+  const versionKeys = Object.keys(byVersion);
+  if (versionKeys.length === 0)
+    return [];
+  return byVersion[Number(versionKeys[0])] ?? [];
+}
 function getPalletNames(meta) {
   return meta.unified.pallets.map((p) => p.name);
 }
@@ -1060,41 +1067,65 @@ async function accountRemove(name) {
 }
 
 // src/commands/tx.ts
+import { Binary } from "polkadot-api";
+import { getViewBuilder } from "@polkadot-api/view-builder";
 function registerTxCommand(cli) {
-  cli.command("tx [target] [...args]", "Submit an extrinsic (e.g. Balances.transferKeepAlive <dest> <amount>)").option("--from <name>", "Account to sign with (required)").option("--dry-run", "Estimate fees without submitting").action(async (target, args, opts) => {
+  cli.command("tx [target] [...args]", "Submit an extrinsic (e.g. Balances.transferKeepAlive <dest> <amount>)").option("--from <name>", "Account to sign with (required)").option("--dry-run", "Estimate fees without submitting").option("--ext <json>", `Custom signed extension values as JSON, e.g. '{"ExtName":{"value":...}}'`).action(async (target, args, opts) => {
     if (!target || !opts.from) {
-      console.log("Usage: dot tx <Pallet.Call> [...args] --from <account> [--dry-run]");
+      console.log("Usage: dot tx <Pallet.Call|0xCallHex> [...args] --from <account> [--dry-run]");
       console.log("");
       console.log("Examples:");
       console.log("  $ dot tx Balances.transferKeepAlive 5FHn... 1000000000000 --from alice");
       console.log("  $ dot tx System.remark 0xdeadbeef --from alice --dry-run");
+      console.log("  $ dot tx 0x0001076465616462656566 --from alice");
       return;
     }
+    const isRawCall = /^0x[0-9a-fA-F]+$/.test(target);
     const config = await loadConfig();
     const { name: chainName, chain: chainConfig } = resolveChain(config, opts.chain);
-    const { pallet, item: callName } = parseTarget(target);
     const signer = await resolveAccountSigner(opts.from);
     const clientHandle = await createChainClient(chainName, chainConfig, opts.rpc);
     try {
       const meta = await getOrFetchMetadata(chainName, clientHandle);
-      const palletNames = getPalletNames(meta);
-      const palletInfo = findPallet(meta, pallet);
-      if (!palletInfo) {
-        throw new Error(suggestMessage("pallet", pallet, palletNames));
-      }
-      const callInfo = palletInfo.calls.find((c) => c.name.toLowerCase() === callName.toLowerCase());
-      if (!callInfo) {
-        const callNames = palletInfo.calls.map((c) => c.name);
-        throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
-      }
-      const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
+      const userExtOverrides = parseExtOption(opts.ext);
+      const customSignedExtensions = buildCustomSignedExtensions(meta, userExtOverrides);
+      const txOptions = Object.keys(customSignedExtensions).length > 0 ? { customSignedExtensions } : undefined;
       const unsafeApi = clientHandle.client.getUnsafeApi();
-      const tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
+      let tx;
+      let callHex;
+      if (isRawCall) {
+        if (args.length > 0) {
+          throw new Error(`Extra arguments are not allowed when submitting a raw call hex.
+` + "Usage: dot tx 0x<call_hex> --from <account>");
+        }
+        const callBinary = Binary.fromHex(target);
+        tx = await unsafeApi.txFromCallData(callBinary);
+        callHex = target;
+      } else {
+        const { pallet, item: callName } = parseTarget(target);
+        const palletNames = getPalletNames(meta);
+        const palletInfo = findPallet(meta, pallet);
+        if (!palletInfo) {
+          throw new Error(suggestMessage("pallet", pallet, palletNames));
+        }
+        const callInfo = palletInfo.calls.find((c) => c.name.toLowerCase() === callName.toLowerCase());
+        if (!callInfo) {
+          const callNames = palletInfo.calls.map((c) => c.name);
+          throw new Error(suggestMessage(`call in ${palletInfo.name}`, callName, callNames));
+        }
+        const callData = parseCallArgs(meta, palletInfo.name, callInfo.name, args);
+        tx = unsafeApi.tx[palletInfo.name][callInfo.name](callData);
+        const encodedCall = await tx.getEncodedData();
+        callHex = encodedCall.asHex();
+      }
+      const decodedStr = decodeCall(meta, callHex);
       if (opts.dryRun) {
         const signerAddress = toSs58(signer.publicKey);
-        console.log(`  ${BOLD}From:${RESET} ${opts.from} (${signerAddress})`);
+        console.log(`  ${BOLD}From:${RESET}   ${opts.from} (${signerAddress})`);
+        console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
+        console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
         try {
-          const fees = await tx.getEstimatedFees(signer.publicKey);
+          const fees = await tx.getEstimatedFees(signer.publicKey, txOptions);
           console.log(`  ${BOLD}Estimated fees:${RESET} ${fees}`);
         } catch (err) {
           console.log(`  ${BOLD}Estimated fees:${RESET} ${YELLOW}unable to estimate${RESET}`);
@@ -1103,8 +1134,10 @@ function registerTxCommand(cli) {
         return;
       }
       console.log("Signing and submitting...");
-      const result = await tx.signAndSubmit(signer);
+      const result = await tx.signAndSubmit(signer, txOptions);
       console.log();
+      console.log(`  ${BOLD}Call:${RESET}   ${callHex}`);
+      console.log(`  ${BOLD}Decode:${RESET} ${decodedStr}`);
       console.log(`  ${BOLD}Tx:${RESET}     ${result.txHash}`);
       if (result.block) {
         console.log(`  ${BOLD}Block:${RESET}  #${result.block.number} (${result.block.hash})`);
@@ -1134,6 +1167,95 @@ function registerTxCommand(cli) {
     }
   });
 }
+function decodeCall(meta, callHex) {
+  try {
+    const viewBuilder = getViewBuilder(meta.lookup);
+    const decoded = viewBuilder.callDecoder(callHex);
+    const palletName = decoded.pallet.value.name;
+    const callName = decoded.call.value.name;
+    const argsStr = formatDecodedArgs(decoded.args.value);
+    return `${palletName}.${callName}${argsStr}`;
+  } catch {
+    return "(unable to decode)";
+  }
+}
+function formatDecodedArgs(decoded) {
+  return formatDecoded(decoded);
+}
+function formatDecoded(d) {
+  switch (d.codec) {
+    case "_void":
+      return "";
+    case "bool":
+      return d.value.toString();
+    case "str":
+    case "char":
+      return d.value;
+    case "u8":
+    case "u16":
+    case "u32":
+    case "i8":
+    case "i16":
+    case "i32":
+    case "compactNumber":
+      return d.value.toString();
+    case "u64":
+    case "u128":
+    case "u256":
+    case "i64":
+    case "i128":
+    case "i256":
+    case "compactBn":
+      return d.value.toString();
+    case "bitSequence":
+      return `0x${Buffer.from(d.value.bytes).toString("hex")}`;
+    case "AccountId":
+      return d.value.address;
+    case "ethAccount":
+      return d.value;
+    case "Bytes":
+      return d.value;
+    case "BytesArray":
+      return d.value;
+    case "Enum": {
+      const inner = formatDecoded(d.value.value);
+      if (!inner)
+        return d.value.type;
+      return `${d.value.type}(${inner})`;
+    }
+    case "Struct": {
+      const entries = Object.entries(d.value);
+      if (entries.length === 0)
+        return " {}";
+      const fields = entries.map(([k, v]) => `${k}: ${formatDecoded(v)}`).join(", ");
+      return ` { ${fields} }`;
+    }
+    case "Tuple": {
+      const items = d.value.map(formatDecoded).join(", ");
+      return `(${items})`;
+    }
+    case "Option": {
+      if (d.value.codec === "_void")
+        return "None";
+      return formatDecoded(d.value);
+    }
+    case "Result": {
+      if (d.value.success) {
+        return `Ok(${formatDecoded(d.value.value)})`;
+      }
+      return `Err(${formatDecoded(d.value.value)})`;
+    }
+    case "Sequence":
+    case "Array": {
+      const items = d.value.map(formatDecoded);
+      if (items.length === 0)
+        return "[]";
+      return `[${items.join(", ")}]`;
+    }
+    default:
+      return String(d.value ?? "");
+  }
+}
 function formatEventValue(v) {
   if (typeof v === "bigint")
     return v.toString();
@@ -1224,6 +1346,13 @@ function parseTypedArg(lookup, entry, arg) {
         } catch {}
       }
       const variants = Object.keys(entry.value);
+      if (variants.includes("Id")) {
+        const idVariant = entry.value["Id"];
+        const innerType = idVariant.type === "lookupEntry" ? idVariant.value : idVariant;
+        if (innerType.type === "AccountId32" && !arg.startsWith("{")) {
+          return { type: "Id", value: arg };
+        }
+      }
       const matched = variants.find((v) => v.toLowerCase() === arg.toLowerCase());
       if (matched) {
         const variant = entry.value[matched];
@@ -1234,15 +1363,22 @@ function parseTypedArg(lookup, entry, arg) {
       return parseValue(arg);
     }
     case "sequence":
-    case "array":
+    case "array": {
+      const inner = entry.value;
+      if (inner.type === "primitive" && inner.value === "u8") {
+        if (/^0x[0-9a-fA-F]*$/.test(arg))
+          return Binary.fromHex(arg);
+        return Binary.fromText(arg);
+      }
       if (arg.startsWith("[")) {
         try {
           return JSON.parse(arg);
         } catch {}
       }
       if (/^0x[0-9a-fA-F]*$/.test(arg))
-        return arg;
+        return Binary.fromHex(arg);
       return parseValue(arg);
+    }
     case "struct":
       if (arg.startsWith("{")) {
         try {
@@ -1286,6 +1422,73 @@ function parsePrimitive(prim, arg) {
       return parseValue(arg);
   }
 }
+var PAPI_BUILTIN_EXTENSIONS = new Set([
+  "CheckNonZeroSender",
+  "CheckSpecVersion",
+  "CheckTxVersion",
+  "CheckGenesis",
+  "CheckMortality",
+  "CheckNonce",
+  "CheckWeight",
+  "ChargeTransactionPayment",
+  "ChargeAssetTxPayment",
+  "CheckMetadataHash",
+  "StorageWeightReclaim",
+  "PrevalidateAttests"
+]);
+function parseExtOption(ext) {
+  if (!ext)
+    return {};
+  try {
+    const parsed = JSON.parse(ext);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`--ext must be a JSON object, e.g. '{"ExtName":{"value":...}}'`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err.message?.startsWith("--ext"))
+      throw err;
+    throw new Error(`Failed to parse --ext JSON: ${err.message}
+` + `Expected format: '{"ExtName":{"value":...}}'`);
+  }
+}
+var NO_DEFAULT = Symbol("no-default");
+function buildCustomSignedExtensions(meta, userOverrides) {
+  const result = {};
+  const extensions = getSignedExtensions(meta);
+  for (const ext of extensions) {
+    if (PAPI_BUILTIN_EXTENSIONS.has(ext.identifier))
+      continue;
+    if (ext.identifier in userOverrides) {
+      result[ext.identifier] = userOverrides[ext.identifier];
+      continue;
+    }
+    const valueEntry = meta.lookup(ext.type);
+    const addEntry = meta.lookup(ext.additionalSigned);
+    const value = autoDefaultForType(valueEntry);
+    const add = autoDefaultForType(addEntry);
+    if (value !== NO_DEFAULT || add !== NO_DEFAULT) {
+      result[ext.identifier] = {
+        ...value !== NO_DEFAULT ? { value } : {},
+        ...add !== NO_DEFAULT ? { additionalSigned: add } : {}
+      };
+    }
+  }
+  return result;
+}
+function autoDefaultForType(entry) {
+  if (entry.type === "void")
+    return new Uint8Array([]);
+  if (entry.type === "option")
+    return;
+  if (entry.type === "enum") {
+    const variants = entry.value;
+    if ("Disabled" in variants) {
+      return { type: "Disabled", value: undefined };
+    }
+  }
+  return NO_DEFAULT;
+}
 
 // src/utils/errors.ts
 class CliError2 extends Error {
@@ -1310,7 +1513,7 @@ registerConstCommand(cli);
 registerAccountCommands(cli);
 registerTxCommand(cli);
 cli.help();
-cli.version("0.2.0");
+cli.version("0.3.0");
 function handleError(err) {
   if (err instanceof CliError2) {
     console.error(`Error: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polkadot-cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CLI tool for querying Polkadot-ecosystem on-chain state",
   "type": "module",
   "bin": {