@everyprotocol/every-cli 0.1.3 → 0.1.4

package/dist/cmds/set.js

@@ -0,0 +1,31 @@
+import { Argument, Command } from "commander";
+import { abi } from "../abi.js";
+import { CommandGenDefaults, getCommandGen, makeFuncName } from "../cmdgen.js";
+const adminCmdConfig = {
+    getFuncName: (cmdName) => `${cmdName}Set`,
+    getAbiFuncs: (funcName) => abi.funcs.setRegistryAdmin.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.setRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => args[0],
+    // eslint-disable-next-line
+    getFuncArgs: (args, abiFunc) => args.slice(1),
+    getCmdArgs: (abiFunc) => [
+        new Argument(`<contract>`, "address of the set contract"),
+        ...CommandGenDefaults.getCmdArgs(abiFunc),
+    ],
+};
+const userCmdConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `set`),
+    getAbiFuncs: (funcName) => abi.funcs.setRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.setRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.SetRegistry,
+};
+const userCmds = "owner,descriptor,snapshot".split(",");
+const adminCmds = "register,update,upgrade,touch".split(",");
+export const setCmd = new Command("set")
+    .description("manage sets")
+    .addCommands(adminCmds.map(getCommandGen(adminCmdConfig)))
+    .addCommands(userCmds.map(getCommandGen(userCmdConfig)));

package/dist/cmds/unique.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `unique`),
+    getAbiFuncs: (funcName) => abi.funcs.elemRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.elemRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.ElementRegistry,
+};
+const cmdGen = getCommandGen(cmdGenConfig);
+const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot".split(",");
+export const uniqueCmd = new Command("unique").description("manage uniques").addCommands(subCmds.map(cmdGen));

package/dist/cmds/universe.js

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import "@polkadot/api-augment/substrate";
+import { submitSubTxUI } from "../substrate.js";
+import { network } from "../commander-patch.js";
+import { parseAccountId, parseBigInt } from "../parsers.js";
+import { Logger } from "../logger.js";
+const universeStartCmd = new Command("start")
+    .description("Start a universe")
+    .argument("<universe>", "Universe ID", parseBigInt)
+    .argument("<horizon>", "Block number", parseBigInt)
+    .argument("<herald>", "Herald address (SS58 or 0x hex)", parseAccountId)
+    .addOption(network)
+    .addKeystoreOptions()
+    .addOutputOptions()
+    .subWriteAction(async function (api, pair, universe, horizon, herald) {
+    const call = api.tx.every.canonicalStart(universe, horizon, herald);
+    const tx = api.tx.sudo.sudo(call);
+    const console = new Logger(this.opts());
+    await submitSubTxUI(api, tx, pair, console);
+});
+export const universeCmd = new Command("universe").description("manage universes").addCommand(universeStartCmd);

package/dist/cmds/value.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `value`),
+    getAbiFuncs: (funcName) => abi.funcs.elemRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.elemRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.ElementRegistry,
+};
+const cmdGen = getCommandGen(cmdGenConfig);
+const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot".split(",");
+export const valueCmd = new Command("value").description("manage values").addCommands(subCmds.map(cmdGen));

package/dist/{wallet.js → cmds/wallet.js}

@@ -3,18 +3,19 @@ import { Keyring } from "@polkadot/keyring";
 import { mnemonicGenerate, cryptoWaitReady } from "@polkadot/util-crypto";
 import { bytesToHex } from "viem";
 import * as fs from "fs";
-import { getPasswordConfirm, keystoreFromAccount, resolveKeystoreDir, saveKeystore } from "./utils.js";
-const listCmd = new Command()
+import { FromOpts } from "../from-opts.js";
+import { saveJson } from "../utils.js";
+const walletListCmd = new Command()
     .name("list")
     .description("List all wallets")
     .option("-f, --foundry", "use foundry keystore directory (~/.foundry/keystores)")
     .option("--dir <dir>", "specify a custom keystore directory")
     .action(async (options) => {
-    const dir = resolveKeystoreDir(options);
+    const dir = FromOpts.getKeystoreDir(options);
     const files = fs.readdirSync(dir);
     files.forEach((file) => console.log(file));
 });
-const generateCmd = new Command()
+const walletNewCmd = new Command()
     .name("new")
     .description("Generate a new wallet")
     .option("-t, --type <type>", "key type (sr25519, ed25519, ethereum)", "sr25519")
@@ -23,15 +24,16 @@ const generateCmd = new Command()
     .option("--dir <dir>", "specify keystore directory")
     .argument("<name>", "name of the wallet")
     .action(async (name, options) => {
-    const password = getPasswordConfirm(options);
+    const password = FromOpts.confirmPassword(options);
     await cryptoWaitReady();
     const keyring = new Keyring();
     const mnemonic = mnemonicGenerate();
     const pair = keyring.addFromUri(mnemonic, { name }, options.type);
     const json = pair.toJson(password);
-    saveKeystore(json, name, options);
+    const dir = FromOpts.getKeystoreDir(options);
+    saveJson(json, dir, name);
 });
-const importCmd = new Command()
+const walletImportCmd = new Command()
     .name("import")
     .description("Import a wallet from a secrete URI")
     .option("-t, --type <type>", "key type (sr25519, ed25519, ethereum)", "sr25519")
@@ -42,14 +44,15 @@ const importCmd = new Command()
     .argument("<name>", "name of the wallet")
     .argument("<suri>", "secret URI")
     .action(async (name, suri, options) => {
-    const password = getPasswordConfirm(options);
+    const password = FromOpts.confirmPassword(options);
     await cryptoWaitReady();
     const keyring = new Keyring({ type: options.type });
     const pair = keyring.addFromUri(suri);
     const json = pair.toJson(password);
-    saveKeystore(json, name, options);
+    const dir = FromOpts.getKeystoreDir(options);
+    saveJson(json, dir, name);
 });
-const inspectCmd = new Command()
+const walletInspectCmd = new Command()
     .name("inspect")
     .description("Inspect a wallet")
     .option("-t, --type <type>", "key type (sr25519, ed25519, ethereum)", "sr25519")
@@ -60,11 +63,8 @@ const inspectCmd = new Command()
     .option("-f, --foundry", "use foundry keystore directory (~/.foundry/keystores)")
     .argument("<name>", "name of the wallet")
     .action(async (name, options) => {
-    const keystore = await keystoreFromAccount(name, options);
-    let decoded;
-    if (options.decrypt) {
-        decoded = await keystore.privateKey();
-    }
+    const keystore = await FromOpts.getKeystore(options, name);
+    const decoded = options.decrypt ? await keystore.privateKey() : undefined;
     let dir = "~/.every/keystores";
     if (options.foundry) {
         dir = "~/.foundry/keystores";
@@ -84,7 +84,7 @@ const inspectCmd = new Command()
 export const walletCmd = new Command()
     .name("wallet")
     .description("manage wallets")
-    .addCommand(listCmd)
-    .addCommand(generateCmd)
-    .addCommand(importCmd)
-    .addCommand(inspectCmd);
+    .addCommand(walletListCmd)
+    .addCommand(walletNewCmd)
+    .addCommand(walletImportCmd)
+    .addCommand(walletInspectCmd);

package/dist/commander-patch.js

@@ -0,0 +1,64 @@
+import { Command, Option } from "commander";
+import { FromOpts } from "./from-opts.js";
+export const account = new Option("-a, --account <account>", "Name of the keystore");
+export const password = new Option("-p, --password [password]", "Password to decrypt the keystore");
+export const passwordFile = new Option("-P, --password-file <file>", "File containing the keystore password");
+export const privateKey = new Option("-k, --private-key <key>", "Private key to sign the transaction");
+export const foundry = new Option("-f, --foundry", "Use foundry keystores (~/.foundry/keystores)");
+export const universe = new Option("-u, --universe <universe>", "Universe name").default("anvil");
+export const network = new Option("-n, --network <network>", "Network name").default("dev");
+export const json = new Option("-j, --json [file]", "Output result as JSON to stdout or file, implies --quiet");
+export const quiet = new Option("-q, --quiet", "Suppress info messages");
+export const noQuiet = new Option("--no-quiet", "Force info messages even when --json is set");
+export const keystoreOptions = [account, password, passwordFile, foundry];
+export const outputOptions = [json, quiet, noQuiet];
+export const writeOptions = [universe, account, password, passwordFile, foundry];
+Command.prototype.addCommands = function (commands) {
+    commands.forEach((cmd) => this.addCommand(cmd));
+    return this;
+};
+Command.prototype.addArguments = function (arg) {
+    arg.forEach((arg) => this.addArgument(arg));
+    return this;
+};
+Command.prototype.addOptions = function (options) {
+    options.forEach((opt) => this.addOption(opt));
+    return this;
+};
+Command.prototype.addKeystoreOptions = function () {
+    return this.addOptions([account, password, passwordFile, foundry]);
+};
+Command.prototype.addOutputOptions = function () {
+    return this.addOptions([json, quiet, noQuiet]);
+};
+Command.prototype.addWriteOptions = function () {
+    return this.addKeystoreOptions().addOption(universe);
+};
+Command.prototype.subReadAction = function (fn) {
+    // eslint-disable-next-line
+    return this.action(async function (...args) {
+        const api = await FromOpts.getSubstrateApi(this.opts());
+        try {
+            return await fn.call(this, api, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    });
+};
+Command.prototype.subWriteAction = function (fn) {
+    // eslint-disable-next-line
+    async function _action(...args) {
+        const opts = this.opts();
+        const api = await FromOpts.getSubstrateApi(opts);
+        try {
+            const keystore = await FromOpts.getKeystore(opts);
+            const pair = await keystore.pair();
+            return await fn.call(this, api, pair, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    }
+    return this.action(_action);
+};

package/dist/config.js

@@ -1,34 +1,9 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { parse as parseTOML } from "@iarna/toml";
 import * as TOML from "@iarna/toml";
-import { __dirname } from "./utils.js";
-// export interface Universe {
-//   name: string;
-//   id: number;
-//   rpc: string;
-//   explorer: string;
-//   observer: string;
-//   contracts: {
-//     setRegistry: string;
-//     omniRegistry: string;
-//     kindRegistry: string;
-//     elementRegistry: string;
-//     objectMinter: string;
-//   };
-// }
-// export interface Observer {
-//   name: string;
-//   rpc: string;
-//   explorer: string;
-//   gateway: string;
-// }
-// export interface Config {
-//   universes: Record<string, Universe>;
-//   observers: Record<string, Observer>;
-// }
 import { z } from "zod";
+import { __dirname } from "./utils.js";
 export const ContractsSchema = z.object({
     SetRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Must be an Ethereum address"),
     OmniRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
@@ -57,18 +32,24 @@ export function loadConfig(file) {
     const raw = TOML.parse(text);
     return ConfigSchema.parse(raw);
 }
-const configPaths = [
-    path.resolve(__dirname, "../.every.toml"),
-    path.resolve(os.homedir(), ".every.toml"),
-    path.resolve(process.cwd(), ".every.toml"),
-];
 export function loadMergedConfig() {
-    const merged = { universes: {}, observers: {} };
-    const existingFiles = configPaths.filter((f) => fs.existsSync(f));
-    if (existingFiles.length === 0) {
-        throw new Error(`No config file found. Searched in:\n  ${configPaths.join("\n  ")}`);
+    const [config] = _loadMergedConfig();
+    return config;
+}
+export function _loadMergedConfig() {
+    const search = [
+        ...new Set([
+            path.resolve(__dirname, "../.every.toml"),
+            path.resolve(os.homedir(), ".every.toml"),
+            path.resolve(process.cwd(), ".every.toml"),
+        ]),
+    ];
+    const files = search.filter((f) => fs.existsSync(f));
+    if (files.length === 0) {
+        throw new Error(`No config file found. Searched in:\n  ${search.join("\n  ")}`);
     }
-    for (const file of existingFiles) {
+    const merged = { universes: {}, observers: {} };
+    for (const file of files) {
         const raw = loadConfig(file);
         if (raw.universes) {
             for (const [name, uni] of Object.entries(raw.universes)) {
@@ -87,61 +68,5 @@ export function loadMergedConfig() {
             }
         }
     }
-    return ConfigSchema.parse(merged);
-}
-// Cache
-let CONFIG_CACHED = null;
-export function getUniverseConfig(opts) {
-    const config = loadProtocolConfig();
-    const universeName = opts.universe || "local";
-    const universe = config.universes[universeName];
-    if (!universe) {
-        const available = Object.keys(config.universes).join(", ");
-        throw new Error(`Universe "${universeName}" not found. Available: ${available}`);
-    }
-    return universe;
-}
-function loadProtocolConfig() {
-    if (CONFIG_CACHED)
-        return CONFIG_CACHED;
-    const configPaths = new Set([
-        path.resolve(__dirname, "../.every.toml"),
-        path.resolve(os.homedir(), ".every.toml"),
-        path.resolve(process.cwd(), ".every.toml"),
-    ]);
-    const mergedConfig = {
-        universes: {},
-    };
-    for (const configPath of configPaths) {
-        if (!fs.existsSync(configPath))
-            continue;
-        try {
-            const raw = fs.readFileSync(configPath, "utf8");
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const parsed = parseTOML(raw);
-            if (parsed.universes) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                for (const [name, uni] of Object.entries(parsed.universes)) {
-                    // console.log(name, uni);
-                    mergedConfig.universes[name] = {
-                        name: name,
-                        id: uni.id,
-                        rpc: uni.rpc,
-                        explorer: uni.explorer,
-                        observer: uni.observer,
-                        contracts: uni.contracts || {},
-                    };
-                }
-            }
-            console.log(`Loaded configuration from ${configPath}`);
-        }
-        catch (err) {
-            console.warn(`Failed to load ${configPath}:`, err);
-        }
-    }
-    if (Object.keys(mergedConfig.universes).length === 0) {
-        console.warn("No universe configurations found");
-    }
-    CONFIG_CACHED = mergedConfig;
-    return CONFIG_CACHED;
+    return [ConfigSchema.parse(merged), files];
 }

package/dist/ethereum.js

@@ -0,0 +1,33 @@
+import { parseEventLogs } from "viem";
+import columnify from "columnify";
+import { stringify as j11 } from "json11";
+export async function submitSimulation(simulation, publicClient, walletClient, console) {
+    console.log("Transaction sending...");
+    const { request } = await publicClient.simulateContract(simulation);
+    const hash = await walletClient.writeContract(request);
+    console.log(`Transaction sent: ${hash}`);
+    console.log("Waiting for confirmation...");
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    console.log(`Confirmed in: block ${receipt.blockNumber}, hash ${receipt.blockHash}`);
+    const output = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const events = [];
+    if (receipt.logs && receipt.logs.length > 0) {
+        const parsedLogs = parseEventLogs({ abi: simulation.abi, logs: receipt.logs });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parsedLogs.forEach((log, i) => {
+            output.push([i, log.eventName, j11(log.args)]);
+            events.push({ name: log.eventName, data: log.args });
+        });
+    }
+    if (output.length > 0) {
+        console.log("Events emitted");
+        const termWidth = process.stdout.columns || 80;
+        const config = {
+            2: { maxWidth: Math.max(60, termWidth - 20) },
+        };
+        console.log(columnify(output, { showHeaders: false, truncateMarker: "", config }));
+    }
+    const result = { transaction: hash, block: { number: receipt.blockNumber, hash: receipt.blockHash }, events };
+    console.result(result);
+}

package/dist/from-opts.js

@@ -0,0 +1,161 @@
+import { bytesToHex, createPublicClient, createWalletClient, http } from "viem";
+import fs from "fs";
+import path from "path";
+import { Wallet } from "ethers";
+import { privateKeyToAccount } from "viem/accounts";
+import promptSync from "prompt-sync";
+import os from "os";
+import { loadMergedConfig } from "./config.js";
+import Keyring from "@polkadot/keyring";
+import { UnifiedKeystore } from "./keystore.js";
+import { decodePairFromJson, loadJson } from "./utils.js";
+import { ApiPromise, WsProvider } from "@polkadot/api";
+export const FromOpts = {
+    getKeystoreDir: function (opts) {
+        if (opts.foundry) {
+            return path.join(os.homedir(), ".foundry", "keystores");
+        }
+        if (opts.dir) {
+            return opts.dir;
+        }
+        return path.join(os.homedir(), ".every", "keystores");
+    },
+    getKeystoreFile: function (opts, name) {
+        const dir = FromOpts.getKeystoreDir(opts);
+        return path.join(dir, name);
+    },
+    getKeystore: async function (opts, account) {
+        const name = account ?? opts.account;
+        if (!name) {
+            throw new Error(`account not specified`);
+        }
+        const keyFile = FromOpts.getKeystoreFile(opts, account ?? opts.account);
+        const keyData = loadJson(keyFile);
+        const password = FromOpts.getPassword(opts);
+        const keystore = await UnifiedKeystore.fromJSON(keyData, password);
+        return keystore;
+    },
+    getPassword: function (opts) {
+        return opts.password
+            ? opts.password
+            : opts.passwordFile
+                ? fs.readFileSync(opts.passwordFile, "utf8").trim()
+                : promptSync({ sigint: true })("Enter keystore password: ", { echo: "" });
+    },
+    confirmPassword: function (opts) {
+        if (opts.password) {
+            return opts.password;
+        }
+        if (opts.passwordFile) {
+            return fs.readFileSync(opts.passwordFile, "utf8").trim();
+        }
+        const prompt = promptSync({ sigint: true });
+        const password = prompt("Enter keystore password: ", { echo: "" });
+        const confirmation = prompt("Re-enter to confirm: ", { echo: "" });
+        if (password !== confirmation) {
+            throw new Error(`Error: Passwords do not match`);
+        }
+        return password;
+    },
+    getUniverseConfig: function (opts) {
+        const config = loadMergedConfig();
+        const universeName = opts.universe;
+        const universe = config.universes[universeName];
+        if (!universe) {
+            const available = Object.keys(config.universes).join(", ");
+            throw new Error(`Universe "${universeName}" not found. Available: ${available}`);
+        }
+        return universe;
+    },
+    getObserverConfig: function (options) {
+        const conf = loadMergedConfig();
+        let observerName;
+        const DEFAULT_OBSERVER = "localnet";
+        if (options.network) {
+            observerName = options.network;
+        }
+        else if (options.universe) {
+            const universe = conf.universes[options.universe];
+            if (!universe) {
+                throw new Error(`Universe '${options.universe}' not found in config. Available: ${Object.keys(conf.universes).join(", ")}`);
+            }
+            observerName = universe.observer;
+        }
+        else {
+            observerName = DEFAULT_OBSERVER;
+        }
+        if (!observerName) {
+            throw new Error(`No observer resolved from options or config.`);
+        }
+        const observer = conf.observers[observerName];
+        if (!observer) {
+            throw new Error(`Observer '${observerName}' not found in config. Available: ${Object.keys(conf.observers).join(", ")}`);
+        }
+        return observer;
+    },
+    getPair: async function (opts) {
+        const keyFile = FromOpts.getKeystoreFile(opts, opts.account);
+        const keyData = loadJson(keyFile);
+        const keyring = new Keyring();
+        const pair = keyring.createFromJson(keyData);
+        if (pair.isLocked) {
+            const password = FromOpts.getPassword(opts);
+            pair.unlock(password);
+        }
+        return pair;
+    },
+    getPrivateKey: async function (opts) {
+        if (opts.privateKey) {
+            return opts.privateKey.startsWith("0x") ? opts.privateKey : `0x${opts.privateKey}`;
+        }
+        else if (opts.account) {
+            const keyFile = FromOpts.getKeystoreFile(opts, opts.account);
+            const keyData = loadJson(keyFile);
+            if (keyData.crypto || keyData.Crypto) {
+                // for Ethereum keystores
+                const password = FromOpts.getPassword(opts);
+                const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keyData), password);
+                return wallet.privateKey;
+            }
+            else if (keyData.encoding || keyData.meta) {
+                // for Substrate keystores, must be ethereum type
+                if (keyData.meta?.isEthereum || keyData.meta?.type === "ethereum") {
+                    const password = FromOpts.getPassword(opts);
+                    const pair = decodePairFromJson(keyData, password);
+                    return bytesToHex(pair.secretKey);
+                }
+                else {
+                    throw new Error("Not an Ethereum account");
+                }
+            }
+            else {
+                // Not supported for now
+                throw new Error("Unknown keystore format");
+            }
+        }
+        else {
+            throw new Error(`Neither account nor private key specified`);
+        }
+    },
+    toWriteEthereum: async function (opts) {
+        const conf = FromOpts.getUniverseConfig(opts);
+        const transport = http(conf.rpc);
+        const publicClient = createPublicClient({ transport });
+        const privateKey = await FromOpts.getPrivateKey(opts);
+        const account = privateKeyToAccount(privateKey);
+        const walletClient = createWalletClient({ account, transport });
+        return { publicClient, walletClient, conf };
+    },
+    toReadEthereum: function (opts) {
+        const conf = FromOpts.getUniverseConfig(opts);
+        const transport = http(conf.rpc);
+        const publicClient = createPublicClient({ transport });
+        return { publicClient, conf };
+    },
+    getSubstrateApi: async function (opts) {
+        const conf = FromOpts.getObserverConfig(opts);
+        const provider = new WsProvider(conf.rpc);
+        const api = await ApiPromise.create({ provider, noInitWarn: true });
+        return api;
+    },
+};

package/dist/index.js

@@ -3,6 +3,7 @@ import { program } from "./program.js";
 try {
     await program.parseAsync();
 }
-catch (e) {
+catch (e /* eslint-disable-line */) {
     console.error(e.message);
+    process.exitCode = 1;
 }

package/dist/logger.js

@@ -0,0 +1,39 @@
+import * as fs from "fs";
+import { stringify as j11 } from "json11";
+import path from "path";
+export class Logger {
+    quiet;
+    json;
+    constructor(opts = {}) {
+        this.quiet = opts.quiet ?? !!opts.json;
+        this.json = opts.json ?? false;
+    }
+    log(...args) {
+        if (!this.quiet)
+            console.error(...args);
+    }
+    warn(...args) {
+        if (!this.quiet)
+            console.error("[warn]", ...args);
+    }
+    error(...args) {
+        console.error("[error]", ...args);
+    }
+    result(data) {
+        const opts = {
+            quote: `"`,
+            quoteNames: true,
+            withBigInt: false,
+        };
+        if (this.json) {
+            if (typeof this.json === "string") {
+                const dir = path.dirname(this.json);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(this.json, j11(data, opts));
+            }
+            else {
+                console.log(j11(data, opts)); // stdout
+            }
+        }
+    }
+}

package/dist/parsers.js

@@ -0,0 +1,59 @@
+import { u8aFixLength } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { InvalidArgumentError } from "commander";
+export function parseBigInt(arg) {
+    try {
+        return BigInt(arg);
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError("invalid bigint");
+    }
+}
+export function parseAccountId(address) {
+    try {
+        return u8aFixLength(decodeAddress(address), 256);
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError("invalid account ID");
+    }
+}
+export function parseNode4(arg) {
+    const parts = arg.split(".");
+    let [data, grant, set, id] = [0n, 0n, 0n, 0n];
+    if (parts.length == 2) {
+        set = BigInt(parts[0]);
+        id = BigInt(parts[1]);
+    }
+    else if (parts.length == 3) {
+        grant = BigInt(parts[0]);
+        set = BigInt(parts[1]);
+        id = BigInt(parts[2]);
+    }
+    else if (parts.length == 4) {
+        data = BigInt(parts[0]);
+        grant = BigInt(parts[1]);
+        set = BigInt(parts[2]);
+        id = BigInt(parts[3]);
+    }
+    else {
+        throw new InvalidArgumentError("invalid Node4");
+    }
+    return (data << 192n) | (grant << 128n) | (set << 64n) | id;
+}
+export function parseNode3(arg) {
+    const parts = arg.split(".");
+    let [grant, set, id] = [0n, 0n, 0n];
+    if (parts.length == 2) {
+        set = BigInt(parts[0]);
+        id = BigInt(parts[1]);
+    }
+    else if (parts.length == 3) {
+        grant = BigInt(parts[0]);
+        set = BigInt(parts[1]);
+        id = BigInt(parts[2]);
+    }
+    else {
+        throw new InvalidArgumentError("invalid Node3");
+    }
+    return (grant << 128n) | (set << 64n) | id;
+}