@everyprotocol/every-cli 0.1.2 → 0.1.4

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;
+}

package/dist/program.js

@@ -1,41 +1,30 @@
 import { Command } from "commander";
-import { generateCommands } from "./cmdgen.js";
-import { RenamingCommand } from "./cmds.js";
 import { version } from "./utils.js";
-import { genWalletCommands } from "./wallet.js";
-import { genMatterCommand } from "./matter.js";
-function buildProgram() {
-    const subCmds = generateCommands();
-    const kindCmd = new RenamingCommand().name("kind").description("manage kinds").addCommands(subCmds.kind);
-    const setCmd = new RenamingCommand().name("set").description("manage sets").addCommands(subCmds.set);
-    const relationCmd = new RenamingCommand()
-        .name("relation")
-        .description("manage relations")
-        .addCommands(subCmds.relation);
-    const uniqueCmd = new RenamingCommand().name("unique").description("manage uniques").addCommands(subCmds.unique);
-    const valueCmd = new RenamingCommand().name("value").description("manage values").addCommands(subCmds.value);
-    const objectCmd = new RenamingCommand()
-        .name("object")
-        .description("create and interact with objects")
-        .addCommands(subCmds.object);
-    const mintPolicyCmd = new RenamingCommand()
-        .name("mintpolicy")
-        .description("manage mint policies")
-        .addCommands(subCmds.mintpolicy);
-    const program = new Command()
-        .name("every")
-        .description("CLI for interacting with Every Protocol")
-        .version(version())
-        .showHelpAfterError(true);
-    program.addCommand(kindCmd);
-    program.addCommand(setCmd);
-    program.addCommand(relationCmd);
-    program.addCommand(uniqueCmd);
-    program.addCommand(valueCmd);
-    program.addCommand(objectCmd);
-    program.addCommand(mintPolicyCmd);
-    program.addCommand(genWalletCommands());
-    program.addCommand(genMatterCommand());
-    return program;
-}
-export const program = buildProgram();
+import { walletCmd } from "./cmds/wallet.js";
+import { matterCmd } from "./cmds/matter.js";
+import { balanceCmd } from "./cmds/balance.js";
+import { configCmd } from "./cmds/config.js";
+import { kindCmd } from "./cmds/kind.js";
+import { valueCmd } from "./cmds/value.js";
+import { uniqueCmd } from "./cmds/unique.js";
+import { relationCmd } from "./cmds/relation.js";
+import { setCmd } from "./cmds/set.js";
+import { objectCmd } from "./cmds/object.js";
+import { minterCmd } from "./cmds/minter.js";
+import { universeCmd } from "./cmds/universe.js";
+export const program = new Command("every")
+    .description("CLI for interacting with Every Protocol")
+    .version(version())
+    .showHelpAfterError(true)
+    .addCommand(universeCmd)
+    .addCommand(matterCmd)
+    .addCommand(setCmd)
+    .addCommand(kindCmd)
+    .addCommand(relationCmd)
+    .addCommand(valueCmd)
+    .addCommand(uniqueCmd)
+    .addCommand(objectCmd)
+    .addCommand(minterCmd)
+    .addCommand(balanceCmd)
+    .addCommand(walletCmd)
+    .addCommand(configCmd);

package/dist/substrate.js

@@ -0,0 +1,63 @@
+import "@polkadot/api-augment/substrate";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { u8aFixLength } from "@polkadot/util";
+import * as JSON11 from "json11";
+import columify from "columnify";
+import { createDeferred } from "./utils.js";
+import "./commander-patch.js";
+export async function submitTransaction(api, tx, pair) {
+    const pTxn = createDeferred();
+    const pReceipt = createDeferred();
+    const accountId = u8aFixLength(decodeAddress(pair.address), 256);
+    const nonce = await api.rpc.system.accountNextIndex(accountId);
+    const unsub = await tx.signAndSend(pair, { nonce }, (result) => {
+        const { status, txHash, events, dispatchError } = result;
+        if (dispatchError) {
+            if (dispatchError.isModule) {
+                const meta = api.registry.findMetaError(dispatchError.asModule);
+                const msg = `${meta.section}.${meta.name}${meta.docs.length ? `: ${meta.docs.join(" ")}` : ""}`;
+                unsub();
+                pReceipt.reject(new Error(`DispatchError: ${msg}`));
+            }
+            else {
+                unsub();
+                pReceipt.reject(new Error(dispatchError.toString()));
+            }
+        }
+        if (status.isReady) {
+            pTxn.resolve({ txHash: txHash.toHex(), receipt: pReceipt.promise });
+        }
+        if (status.isFinalized) {
+            unsub();
+            pReceipt.resolve({
+                txHash: txHash.toHex(),
+                blockHash: status.asFinalized.toHex(),
+                events: events,
+                result,
+            });
+        }
+    });
+    return await pTxn.promise;
+}
+export async function submitSubTxUI(api, tx, pair, console) {
+    console.log(`Transaction submitting...`);
+    const txn = await submitTransaction(api, tx, pair);
+    console.log(`Transaction submitted: ${txn.txHash}`);
+    console.log("Waiting for confirmation...");
+    const r = await txn.receipt;
+    const header = await api.rpc.chain.getHeader(r.blockHash);
+    console.log(`Confirmed in: block ${header.number}, hash ${header.hash}`);
+    const events = r.events.map((e, i) => [i, e.event.method, JSON11.stringify(e.event.data.toJSON())]);
+    const result = r.events.map((e) => {
+        const event = {
+            event: e.event.method,
+            data: e.event.data.toJSON(),
+        };
+        return event;
+    });
+    if (events.length > 0) {
+        console.log(`Events`);
+        console.log(columify(events, { showHeaders: false }));
+    }
+    console.result(result);
+}

package/dist/utils.js

@@ -1,125 +1,25 @@
-import { bytesToHex, createPublicClient, createWalletClient, encodeAbiParameters, http, } from "viem";
-import { formatAbiParameter } from "abitype";
 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 JSON5 from "json5";
 import { fileURLToPath } from "url";
 import { isHex, hexToU8a } from "@polkadot/util";
 import { base64Decode } from "@polkadot/util-crypto/base64";
 import { decodePair } from "@polkadot/keyring/pair/decode";
-import Keyring from "@polkadot/keyring";
+import { getAddress, isAddress, pad, sha256 } from "viem";
+import { FromOpts } from "./from-opts.js";
 export const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function version() {
     const pkgPath = path.resolve(__dirname, "../package.json");
     return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
 }
-export function lstrip(prefix) {
-    return function (func) {
-        return func.name.startsWith(prefix) ? func.name.substring(prefix.length).toLowerCase() : func.name;
-    };
-}
-export function rstrip(postfix) {
-    return function (func) {
-        return func.name.endsWith(postfix) ? func.name.slice(0, -postfix.length) : func.name;
-    };
-}
-export function startsWith(prefix) {
-    return function (func) {
-        return func.name.startsWith(prefix);
-    };
-}
-export function excludes(names) {
-    return function (func) {
-        return !names.includes(func.name);
-    };
-}
-export function includes(names) {
-    return function (f) {
-        return names.includes(f.name);
-    };
-}
-export function stringify(o) {
-    const replacer = (_key, value) => (typeof value === "bigint" ? value.toString() : value);
-    return JSON5.stringify(o, replacer);
-}
-export async function getClientsEth(uniConf, opts) {
-    const transport = http(uniConf.rpc);
-    const publicClient = createPublicClient({ transport });
-    const privateKey = await readPrivateKeyEth(opts);
-    const account = privateKeyToAccount(privateKey);
-    const walletClient = createWalletClient({ account, transport });
-    return { publicClient, walletClient };
-}
-export async function readPrivateKeyEth(opts) {
-    if (opts.privateKey) {
-        return opts.privateKey.startsWith("0x") ? opts.privateKey : `0x${opts.privateKey}`;
-    }
-    else if (opts.account) {
-        const keystorePath = resolveKeystoreFile(opts.account, opts);
-        const keystore = loadKeystore(keystorePath);
-        if (keystore.crypto || keystore.Crypto) {
-            // for Ethereum keystores
-            const password = getPassword(opts);
-            const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keystore), password);
-            return wallet.privateKey;
-        }
-        else if (keystore.encoding || keystore.meta) {
-            // for Substrate keystores
-            if (keystore.meta?.isEthereum || keystore.meta?.type === "ethereum") {
-                const password = getPassword(opts);
-                const pair = decodeSubstratePair(keystore, 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`);
-    }
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function checkArguments(raw, func) {
-    return raw.map((rawArg, index) => {
-        const abiParam = func.inputs[index];
-        const pt = abiParam?.type;
-        const arg = pt === "address" || pt.startsWith("bytes") || pt === "string" ? rawArg : JSON5.parse(rawArg);
-        try {
-            encodeAbiParameters([abiParam], [arg]);
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                throw new Error(`invalid param ${formatAbiParameter(abiParam)}\n${e.message}`);
-            }
-        }
-        return arg;
-    });
-}
-export function resolveKeystoreDir(options) {
-    if (options.foundry) {
-        return path.join(os.homedir(), ".foundry", "keystores");
-    }
-    if (options.dir) {
-        return options.dir;
+export function loadJson(file) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`Keystore file not found: ${file}`);
     }
-    return path.join(os.homedir(), ".every", "keystores");
-}
-export function resolveKeystoreFile(name, options) {
-    const dir = resolveKeystoreDir(options);
-    return path.join(dir, name);
+    return JSON.parse(fs.readFileSync(file, "utf8"));
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function saveKeystore(json, name, options) {
-    const dir = resolveKeystoreDir(options);
+// eslint-disable-next-line
+export function saveJson(json, dir, name) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
@@ -128,54 +28,157 @@ export function saveKeystore(json, name, options) {
         throw new Error(`File exists: ${file}`);
     }
     fs.writeFileSync(file, JSON.stringify(json));
-    console.log(`File saved: ${file}`);
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function loadKeystore(file) {
-    if (!fs.existsSync(file)) {
-        throw new Error(`Keystore file not found: ${file}`);
+export function decodePairFromJson(keystore, password) {
+    const encodedRaw = keystore.encoded;
+    let encodingType = keystore.encoding.type;
+    encodingType = !Array.isArray(encodingType) ? [encodingType] : encodingType;
+    const encoded = isHex(encodedRaw) ? hexToU8a(encodedRaw) : base64Decode(encodedRaw);
+    const decoded = decodePair(password, encoded, encodingType);
+    return decoded;
+}
+export function guessContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".txt":
+            return "text/plain";
+        case ".json":
+            return "application/json";
+        case ".wasm":
+            return "application/wasm";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        default:
+            return "application/octet-stream";
     }
-    return JSON.parse(fs.readFileSync(file, "utf8"));
 }
-export function getPassword(opts) {
-    return opts.password
-        ? opts.password
-        : opts.passwordFile
-            ? fs.readFileSync(opts.passwordFile, "utf8").trim()
-            : promptSync({ sigint: true })("Password: ", { echo: "" });
+export function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+const isArrayType = (t) => /\[[^\]]*\]$/.test(t);
+const isTupleType = (t) => t.startsWith("tuple");
+const elemType = (t) => t.replace(/\[[^\]]*\]$/, "");
+// const fmtInputs = (ins: ReadonlyArray<Pick<AbiParameter, "name" | "type">>) =>
+//   ins.map((i) => (i.name ? `${i.type} ${i.name}` : i.type)).join(", ");
+function hasComponents(p) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return p.components !== "undefined";
+}
+function coerceScalar(val, type) {
+    const base = elemType(type);
+    if (base === "address") {
+        if (!isAddress(val))
+            throw new Error(`Invalid address: ${val}`);
+        return getAddress(val);
+    }
+    if (base === "bool") {
+        if (!/^(true|false)$/i.test(val))
+            throw new Error(`Invalid bool: ${val}`);
+        return /^true$/i.test(val);
+    }
+    if (base === "string")
+        return val;
+    if (base.startsWith("bytes")) {
+        if (!/^0x[0-9a-fA-F]*$/.test(val))
+            throw new Error(`Invalid ${base} (expect 0x...)`);
+        return val;
+    }
+    if (base.startsWith("uint") || base.startsWith("int")) {
+        try {
+            return val.startsWith("0x") ? BigInt(val) : BigInt(val);
+        }
+        catch {
+            throw new Error(`Invalid ${base}: ${val}`);
+        }
+    }
+    return val;
+}
+export function coerceValue(val, param) {
+    const { type } = param;
+    // arrays: expect JSON array; recurse on element type (preserve components if tuple[])
+    if (isArrayType(type)) {
+        const arr = JSON.parse(val);
+        if (!Array.isArray(arr))
+            throw new Error(`Expected array for ${type}`);
+        // build element param (carry tuple components if present)
+        const inner = hasComponents(param)
+            ? { ...param, type: elemType(type), components: param.components }
+            : { ...param, type: elemType(type) };
+        return arr.map((v) => coerceValue(typeof v === "string" ? v : JSON.stringify(v), inner));
+    }
+    // tuples: need components
+    if (isTupleType(type)) {
+        if (!hasComponents(param) || param.components.length === 0) {
+            throw new Error(`Tuple components missing for ${type}`);
+        }
+        const tup = JSON.parse(val);
+        if (Array.isArray(tup)) {
+            if (tup.length !== param.components.length) {
+                throw new Error(`Tuple length mismatch: expected ${param.components.length}, got ${tup.length}`);
+            }
+            return param.components.map((c, i) => coerceValue(typeof tup[i] === "string" ? tup[i] : JSON.stringify(tup[i]), c));
+        }
+        // object by names
+        return param.components.map((c) => {
+            const v = tup[c.name];
+            if (v === undefined)
+                throw new Error(`Tuple field missing: ${c.name}`);
+            return coerceValue(typeof v === "string" ? v : JSON.stringify(v), c);
+        });
+    }
+    // scalar
+    return coerceScalar(val, type);
 }
-export function getPasswordConfirm(opts) {
-    if (opts.password) {
-        return opts.password;
+export async function substrateAction(cmd, api, fn) {
+    try {
+        return await fn(api);
     }
-    if (opts.passwordFile) {
-        return fs.readFileSync(opts.passwordFile, "utf8").trim();
+    catch (e /* eslint-disable-line */) {
+        cmd.error(e.message);
     }
-    const prompt = promptSync({ sigint: true });
-    const password = prompt("Password: ", { echo: "" });
-    const confirmation = prompt("Confirm: ", { echo: "" });
-    if (password !== confirmation) {
-        throw new Error(`Error: Passwords do not match`);
+    finally {
+        api.disconnect().catch(() => { });
     }
-    return password;
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function decodeSubstratePair(keystore, password) {
-    const encodedRaw = keystore.encoded;
-    let encodingType = keystore.encoding.type;
-    encodingType = !Array.isArray(encodingType) ? [encodingType] : encodingType;
-    const encoded = isHex(encodedRaw) ? hexToU8a(encodedRaw) : base64Decode(encodedRaw);
-    const decoded = decodePair(password, encoded, encodingType);
-    return decoded;
+export function wrapSubAction(fn) {
+    // eslint-disable-next-line
+    return async function (...args) {
+        const api = await FromOpts.getSubstrateApi(this.opts());
+        try {
+            // keep Commander’s `this` binding and pass api first
+            return await fn.call(this, api, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    };
 }
-export function getSubstrateAccountPair(flags) {
-    const keyFile = resolveKeystoreFile(flags.account, flags);
-    const keyData = loadKeystore(keyFile);
-    const keyring = new Keyring();
-    const pair = keyring.createFromJson(keyData);
-    if (pair.isLocked) {
-        const password = getPassword(flags);
-        pair.unlock(password);
+export function loadBinary(file) {
+    const buf = fs.readFileSync(file);
+    return buf;
+}
+export function computeMatterHash(form, mime, blob) {
+    if (!Number.isInteger(form) || form < 0 || form > 255) {
+        throw new Error("form must be uint8 (0..255)");
+    }
+    const mimeUTF8 = new TextEncoder().encode(mime);
+    if (mimeUTF8.length <= 0 || mimeUTF8.length > 31) {
+        throw new Error("form must be uint8 (0..255)");
     }
-    return pair;
+    const msg = new Uint8Array(1 + 31 + blob.length);
+    msg[0] = form & 0xff;
+    msg.set(pad(mimeUTF8, { size: 32, dir: "right" }), 1);
+    msg.set(blob, 32);
+    // SHA256(form:1 || mime:31 || blob:var)
+    return sha256(msg);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "files": [
     "dist/",
     "abis/",
@@ -15,6 +15,7 @@
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@types/bun": "latest",
+    "@types/columnify": "^1.5.4",
     "@types/lodash-es": "^4.17.12",
     "@types/prompt-sync": "^4.2.3",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
@@ -32,8 +33,10 @@
     "@polkadot/keyring": "^13.5.2",
     "@polkadot/util": "^13.5.2",
     "@polkadot/util-crypto": "^13.5.2",
+    "columnify": "^1.6.0",
     "commander": "^13.1.0",
     "ethers": "^6.14.0",
+    "json11": "^2.0.2",
     "json5": "^2.2.3",
     "lodash-es": "^4.17.21",
     "prompt-sync": "^4.2.0",