@everyprotocol/every-cli 0.1.4 → 0.1.6

package/.every.toml

@@ -1,8 +1,8 @@
 [universes.anvil]
 id = 31337
-rpc = "http://127.0.0.1:8545"
-explorer = "http://127.0.0.1:8545"
+rpc = "http://localhost:8545"
 observer = "dev"
+explorer = "http://localhost"
 
 [universes.anvil.contracts]
 SetRegistry = "0x854C35Fd2b65fE9fcE71dddE91De8c3e1A7Dc8Ae"
@@ -13,5 +13,5 @@ ObjectMinter = "0x12CaBC370b316F247126F3Fab529Ee25e03aE226"
 
 [observers.dev]
 rpc = "ws://localhost:9944"
-gateway = "http://localhost:3456"
-explorer = "http://every.im.local"
+gateway = "http://every.lo"
+explorer = "https://portal.every.fun/?rpc=ws://localhost:9944#/explorer"

package/dist/cmdgen.js

@@ -9,8 +9,8 @@ import { coerceValue } from "./utils.js";
 const getReadAction = (config, funName, abiFunc, abi) => async function readAction() {
     const opts = this.opts();
     const conf = FromOpts.getUniverseConfig(opts);
-    const address = await config.getContract(conf, this.args, abiFunc);
-    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.args, abiFunc);
+    const address = await config.getContract(conf, this.processedArgs, abiFunc);
+    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.processedArgs, abiFunc);
     const console = new Logger(opts);
     const publicClient = createPublicClient({ transport: http(conf.rpc) });
     const result = await publicClient.readContract({ address, abi, functionName: funName, args });

package/dist/cmds/matter.js

@@ -3,31 +3,38 @@ import "@polkadot/api-augment/substrate";
 import * as fs from "fs";
 import * as JSON11 from "json11";
 import columify from "columnify";
-import { computeMatterHash, guessContentType, loadBinary } from "../utils.js";
+import { loadBinary, loadJson } from "../utils.js";
 import { submitTransaction } from "../substrate.js";
 import { network } from "../commander-patch.js";
 import { Logger } from "../logger.js";
+import path from "path";
+import csv from "csv-parser";
+import { fromHex, pad, sha256 } from "viem";
+import { memoize } from "lodash-es";
 const matterRegisterCmd = new Command("register")
-    .description("Register matter on the Substrate chain")
+    .description("Register matters")
     .argument("<files...>", "Paths of matter blob files")
-    .option("--mime <string>", "Matter mime")
-    .option("--form <number>", "Matter form", "1")
     .addOption(network)
     .addKeystoreOptions()
     .addOutputOptions()
     .subWriteAction(async function (api, pair, files) {
     const opts = this.opts();
     const console = new Logger(opts);
-    const materials = [];
+    const deduper = new Set();
+    const inputs = [];
     for (const file of files) {
-        const [filePath, form_, mime_] = file.split(":");
-        const form = Number(form_ ?? opts.form ?? "1");
-        const mime = mime_ || opts.mime || guessContentType(filePath);
-        materials.push({ filePath, form, mime });
+        const spec = parseFileSpec(file);
+        const mi = await toRegisterInput(spec);
+        mi.forEach((input) => {
+            if (!deduper.has(input.path)) {
+                inputs.push(input);
+                deduper.add(input.path);
+            }
+        });
     }
     const txns = [];
-    for (const { filePath, form, mime } of materials) {
-        const content = fs.readFileSync(filePath);
+    for (const { blob, form, mime, path: filePath } of inputs) {
+        const content = blob || fs.readFileSync(filePath);
         console.log(`Register matter: form=${form} mime=${mime} blob=${content.length}B ${filePath}`);
         const contentRaw = api.createType("Raw", content, content.length);
         const call = api.tx.every.matterRegister(form, mime, contentRaw);
@@ -44,7 +51,9 @@ const matterRegisterCmd = new Command("register")
         const header = await api.rpc.chain.getHeader(r.blockHash);
         console.log(`Transaction confirmed: ${txn.txHash} ${filePath}`);
         console.log(`Confirmed in: block ${header.number}, hash ${header.hash}`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const events = r.events.map((e) => [e.event.method, JSON11.stringify(e.event.data.toJSON())]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const receipt = r.events.map((e) => ({ event: e.event.method, data: e.event.data.toJSON() }));
         console.log(columify(events, { showHeaders: false }));
         result.push({
@@ -55,28 +64,369 @@ const matterRegisterCmd = new Command("register")
     }
     console.result(result);
 });
+const matterCompileCmd = new Command("compile")
+    .description("Compile matters from human-readable to binary")
+    .argument("<files...>", "Paths to matter files")
+    .option("-o, --out <dir>", "Output directory")
+    .addOutputOptions()
+    .action(async function (files) {
+    const opts = this.opts();
+    const console = new Logger(opts);
+    const specs = files.map((f) => parseFileSpec(f));
+    if (specs.find((spec) => spec.type != "raw")) {
+        throw new Error("invalid input, only .enum.csv or .perm.csv files supported");
+    }
+    for (const spec of specs) {
+        const { binFile, depsFile, outDir, compile } = getOutFiles(spec.path, opts.out);
+        const { blob, deps } = await compile(spec.path);
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(binFile, blob, "binary");
+        console.log(`blob saved to ${binFile}`);
+        fs.writeFileSync(depsFile, JSON.stringify(deps));
+        console.log(`deps saved to ${depsFile}`);
+    }
+});
 const matterHashCmd = new Command("hash")
-    .description("Register matter on the Substrate chain")
+    .description("Compute matter hashes")
     .argument("<files...>", "Paths of matter blob files")
-    .option("--mime <string>", "Matter mime")
-    .option("--form <number>", "Matter form", "1")
     .addOutputOptions()
     .action(async function (files) {
     const opts = this.opts();
     const console = new Logger(opts);
-    const matters = [];
+    const seen = new Set();
+    const outputs = [];
     for (const file of files) {
-        const [path, form_, mime_] = file.split(":");
-        const form = Number(form_ ?? opts.form ?? "1");
-        const mime = mime_ || opts.mime || guessContentType(path);
-        const blob = loadBinary(path);
-        const hash = computeMatterHash(form, mime, blob);
-        matters.push({ hash, form, mime, blob: blob.length, path });
-    }
-    console.log(columify(matters));
-    console.result(matters);
+        const spec = parseFileSpec(file);
+        const inputs = await toRegisterInput(spec);
+        inputs.forEach((input) => {
+            if (!seen.has(input.path)) {
+                seen.add(input.path);
+                const { form, mime, path } = input;
+                const blob = input.blob || loadBinary(path);
+                const hash = computeHash(form, mime, blob);
+                outputs.push({ hash, form, mime, path });
+            }
+        });
+    }
+    console.log(columify(outputs));
+    console.result(outputs);
+});
+export const matterPickCmd = new Command("pick")
+    .description("Pick matter hashes from a hash output file")
+    .argument("<files...>", "Paths of the matter files")
+    .option("--from <file>", "Path to the hash output file", "register/hashes.json")
+    .action(function (files) {
+    const opts = this.opts();
+    const list = loadJson(opts.from);
+    if (!Array.isArray(list))
+        throw new Error(`Expected an array in ${opts.from}`);
+    const hashes = list;
+    const result = files.map((file) => {
+        const rec = hashes.find((r) => r.path === file);
+        if (!rec)
+            throw new Error(`No hash found for: ${file}`);
+        return rec.hash;
+    });
+    console.log(result.join(" "));
 });
 export const matterCmd = new Command("matter")
     .description("matter utilities")
     .addCommand(matterRegisterCmd)
-    .addCommand(matterHashCmd);
+    .addCommand(matterCompileCmd)
+    .addCommand(matterHashCmd)
+    .addCommand(matterPickCmd);
+function parseFileSpec(file) {
+    if (file.startsWith("@")) {
+        const p = file.slice(1).trim();
+        if (!p)
+            throw new Error("Invalid manifest file spec (empty path)");
+        return { path: p, type: "manifest" };
+    }
+    const parts = file.split(":");
+    if (parts.length < 1 || parts.length > 3) {
+        throw new Error(`Invalid matter spec: ${file}`);
+    }
+    const pathPart = parts[0];
+    let form;
+    let mime;
+    parts.slice(1).forEach((part) => {
+        if (part.startsWith("form=")) {
+            form = Number(part.slice(5));
+        }
+        else if (part.startsWith("mime=")) {
+            mime = part.slice(5);
+        }
+        else {
+            throw new Error(`Invalid extra info: ${part}`);
+        }
+    });
+    const type = pathPart.endsWith(".enum.csv") || pathPart.endsWith(".perm.csv") ? "raw" : "blob";
+    return { path: pathPart, type, form, mime };
+}
+async function toRegisterInput(spec) {
+    if (spec.type == "blob") {
+        if (spec.form && spec.mime)
+            return [{ path: spec.path, form: spec.form, mime: spec.mime }];
+        const g = inferMatterMeta(spec.path);
+        return [{ path: spec.path, form: spec.form ?? g.form, mime: spec.mime ?? g.mime }];
+    }
+    else if (spec.type == "manifest") {
+        return loadJson(spec.path).map((item) => {
+            const { path, form, mime } = item;
+            return { path, form, mime };
+        });
+    }
+    else if (spec.type == "raw") {
+        if (spec.path.endsWith(".enum.csv")) {
+            const { blob, deps } = await compileEnumMatter(spec.path);
+            const path = spec.path.slice(0, -9) + ".enum.bin";
+            const { form, mime } = inferMatterMeta(path);
+            return [...deps, { blob, form, mime, path }];
+        }
+        else if (spec.path.endsWith(".perm.csv")) {
+            const { blob, deps } = await compileEnumMatter(spec.path);
+            const path = spec.path.slice(0, -9) + ".perm.bin";
+            const { form, mime } = inferMatterMeta(path);
+            return [...deps, { blob, form, mime, path }];
+        }
+        else {
+            throw new Error("unknown raw matter file extension");
+        }
+    }
+    else {
+        throw new Error("unknown matter file type");
+    }
+}
+function getOutFiles(file, outDir) {
+    const dir = outDir ? path.resolve(outDir) : path.dirname(path.resolve(file));
+    if (file.endsWith(".enum.csv")) {
+        const baseName = path.basename(file).slice(0, -9);
+        const binFile = path.join(dir, `${baseName}.enum.bin`);
+        const depsFile = path.join(dir, `${baseName}.enum.deps`);
+        return { binFile, depsFile, outDir: dir, compile: compileEnumMatter };
+    }
+    else if (file.endsWith(".perm.csv")) {
+        const baseName = path.basename(file).slice(0, -9);
+        const binFile = path.join(dir, `${baseName}.perm.bin`);
+        const depsFile = path.join(dir, `${baseName}.perm.deps`);
+        return { binFile, depsFile, outDir: dir, compile: compilePermMatter };
+    }
+    else {
+        throw new Error("Unsupported raw matter file extension");
+    }
+}
+async function compileEnumMatter(file) {
+    const computeHashMemo = memoize(computeHashFile);
+    const deps = new Map();
+    let rows = 0;
+    let colTypes;
+    const mapHeaders = ({ header }) => {
+        const h = header.trim().toUpperCase();
+        if (h in CELL_FORMS) {
+            return h;
+        }
+        else {
+            throw new Error(`Invalid column element type: ${h}`);
+        }
+    };
+    const mapValues = ({ header, value }) => {
+        const v = value.trim();
+        if (v.startsWith("0x")) {
+            return fromHex(pad(v, { size: 32, dir: "left" }), "bytes");
+        }
+        else if (header == "IMAGE" || header == "JSON") {
+            const { hash, mime, form, path } = computeHashMemo(v);
+            if (!deps.has(path)) {
+                deps.set(path, { hash, mime, form, path });
+            }
+            return fromHex(hash, "bytes");
+        }
+        else {
+            throw new Error("expect hex strings for cols other than IMAGE, JSON");
+        }
+    };
+    const aux = parseAuxData(file, { mapValues, mapHeaders });
+    const parser = csv({ skipComments: true, strict: true, mapHeaders, mapValues });
+    const blob = await new Promise((resolve, reject) => {
+        const content = [];
+        fs.createReadStream(file)
+            .pipe(parser)
+            .on("headers", (headers) => {
+            colTypes = headers;
+        })
+            .on("data", (data) => {
+            Object.values(data).forEach((value) => content.push(value));
+            rows += 1;
+        })
+            .on("end", () => {
+            const auxTypes = Object.keys(aux ?? {});
+            const auxValues = Object.values(aux ?? {});
+            const enumHeader = buildEnumHeader(auxTypes, colTypes, rows);
+            resolve(Buffer.concat([enumHeader, ...auxValues, ...content]));
+        })
+            .on("error", (e /* eslint-disable-line */) => {
+            reject(e);
+        });
+    });
+    return { blob, deps: Array.from(deps.values()) };
+}
+async function compilePermMatter(file) {
+    void file;
+    throw new Error("unimplemented");
+}
+function computeHash(form, mime, blob) {
+    if (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)");
+    }
+    const msg = new Uint8Array(32 + 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);
+}
+function computeHashFile(file) {
+    const spec = parseFileSpec(file);
+    if (spec.type != "blob") {
+        throw new Error("not blob type");
+    }
+    let form, mime;
+    if (spec.form && spec.mime) {
+        form = spec.form;
+        mime = spec.mime;
+    }
+    else {
+        const g = inferMatterMeta(spec.path);
+        form = spec.form ?? g.form;
+        mime = spec.mime ?? g.mime;
+    }
+    const hash = computeHash(form, mime, loadBinary(spec.path));
+    return { path: spec.path, form, mime, hash };
+}
+/**
+ * Build a 32-byte EnumMatter header.
+ * Layout:
+ *   [0..3]   = "ENUM"
+ *   [4]      = ver, aux (u8.hi4, u8.lo4)
+ *   [5]      = cols (u8)
+ *   [6..7]   = rows (u16 LE)
+ *   [8..15]  = aux_types [u8; 8]
+ *   [16..31] = col_types [u8; 16]
+ */
+function buildEnumHeader(auxTypes, colTypes, rows = 0) {
+    if (colTypes.length === 0 && auxTypes.length === 0) {
+        throw new Error("Empty header list");
+    }
+    if (auxTypes.length > 8) {
+        throw new Error(`Too many aux types (max 8): ${auxTypes.length}`);
+    }
+    if (colTypes.length > 16) {
+        throw new Error(`Too many column types (max 16): ${colTypes.length}`);
+    }
+    if (rows < 0 || rows > 0xffff) {
+        throw new Error(`Rows out of range: ${rows}`);
+    }
+    const buf = new Uint8Array(32);
+    buf.set([0x45, 0x4e, 0x55, 0x4d], 0); // magic "ENUM"
+    buf[4] = (0x01 << 4) | (auxTypes.length & 0x0f); // version(hi4), aux(lo4)
+    buf[5] = colTypes.length; // cols
+    buf[6] = rows & 0xff; // rows.lo
+    buf[7] = (rows >>> 8) & 0xff; // rows.hi
+    auxTypes.forEach((t, i) => (buf[8 + i] = formByName(t))); // aux types
+    colTypes.forEach((t, i) => (buf[16 + i] = formByName(t))); // col types
+    return buf;
+}
+const MATTER_FORMS = {
+    // Simple
+    JSON: 0x01,
+    IMAGE: 0x02,
+    // Code
+    WASM: 0xc0,
+    // Data
+    ENUM: 0xd0,
+    PERM: 0xd1,
+    // Info
+    INFO: 0xff,
+};
+const CELL_FORMS = {
+    JSON: 0x01,
+    IMAGE: 0x02,
+    INFO: 0xff,
+};
+function formByName(name) {
+    const value = MATTER_FORMS[name];
+    if (value === undefined) {
+        throw new Error(`Invalid form name: "${name}"`);
+    }
+    return value;
+}
+function inferMatterMeta(filePath) {
+    const ext = path.extname(filePath);
+    switch (ext) {
+        case ".wasm":
+            return { mime: "application/wasm", form: MATTER_FORMS.WASM };
+        case ".json":
+            return { mime: "application/json", form: MATTER_FORMS.JSON };
+        case ".jpg":
+            return { mime: "image/jpeg", form: MATTER_FORMS.IMAGE };
+        case ".jpeg":
+            return { mime: "image/jpeg", form: MATTER_FORMS.IMAGE };
+        case ".png":
+            return { mime: "image/png", form: MATTER_FORMS.IMAGE };
+        case ".bin":
+            if (filePath.endsWith(".enum.bin")) {
+                return { mime: "application/vnd.every.enum", form: MATTER_FORMS.ENUM };
+            }
+            else if (filePath.endsWith(".perm.bin")) {
+                return { mime: "application/vnd.every.perm", form: MATTER_FORMS.PERM };
+            }
+            else {
+                throw new Error("unknown matter file extension");
+            }
+        default:
+            throw new Error("unknown matter file extension");
+    }
+}
+function parseAuxData(filePath, options) {
+    const lines = readPrologue(filePath)
+        .filter((l) => /^\s*#\s*@aux\s+/i.test(l))
+        .map((l) => l.replace(/^\s*#\s*@aux\s+/i, "").trim());
+    const mapHeaders = options.mapHeaders ?? (({ header }) => header);
+    const mapValues = options.mapValues ?? (({ value }) => value);
+    if (lines.length == 0) {
+        return undefined;
+    }
+    else if (lines.length == 2) {
+        const headers = lines[0].split(",").map((header, index) => mapHeaders({ header, index }));
+        const parts = lines[1].split(",");
+        if (parts.length != headers.length) {
+            throw new Error("aux header and values mismatch");
+        }
+        const values = parts.map((value, index) => mapValues({ header: headers[index], index, value }));
+        return Object.fromEntries(headers.map((h, i) => [h, values[i]]));
+    }
+    else {
+        throw new Error("invalid aux data");
+    }
+}
+function readPrologue(filePath, maxBytes = 2048) {
+    const fd = fs.openSync(filePath, "r");
+    const buf = Buffer.alloc(maxBytes);
+    const bytesRead = fs.readSync(fd, buf, 0, maxBytes, 0);
+    fs.closeSync(fd);
+    const lines = buf.subarray(0, bytesRead).toString("utf8").split(/\r?\n/);
+    const prologue = [];
+    for (const line of lines) {
+        if (line.trim().startsWith("#")) {
+            prologue.push(line);
+        }
+        else if (line.trim().length > 0) {
+            break; // stop at the first non-comment, non-empty line
+        }
+    }
+    return prologue;
+}

package/dist/cmds/object.js

@@ -4,7 +4,7 @@ import { parseAbiItem, erc1155Abi, erc721Abi } from "viem";
 import { abi } from "../abi.js";
 import { submitSimulation } from "../ethereum.js";
 import { Logger } from "../logger.js";
-import { parseBigInt, parseNode3, parseNode4 } from "../parsers.js";
+import { parseBigInt, parseNode3, parseNode4, parseSID } from "../parsers.js";
 import { CommandGenDefaults, getCommandGen } from "../cmdgen.js";
 import { FromOpts } from "../from-opts.js";
 import { coerceValue } from "../utils.js";
@@ -67,7 +67,7 @@ const cmdGenConfig = {
         return abiFunc.name == "uri" ? args.slice(1) : [args[0].id, ...args.slice(1)];
     },
     getCmdArgs: function (abiFunc) {
-        const sid = new Argument(`<sid>`, "sid of the object");
+        const sid = new Argument(`<sid>`, "sid of the object").argParser(parseSID);
         const args0 = CommandGenDefaults.getCmdArgs(abiFunc);
         return abiFunc.name == "uri" ? [sid] : [sid, ...args0.slice(1)];
     },

package/dist/cmds/pick.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import jp from "jsonpath";
+import * as _ from "lodash-es";
+import { Command } from "commander";
+const DEFAULT_DIR = "./register";
+const STATIC_RULES = {
+    // contract
+    "deploy.addr": {
+        file: "deploy.json",
+        root: "$",
+        field: "deployedTo",
+    },
+    // kind
+    "kind.id": { file: "kind.json", root: "$.events[?(@.name=='KindRegistered')].data", field: "id" },
+    "kind.rev": { file: "kind.json", root: "$.events[?(@.name=='KindRegistered')].data.desc", field: "rev" },
+    "kind.krev": { file: "kind.json", root: "$.events[?(@.name=='KindRegistered')].data.desc", field: "kindRev" },
+    "kind.srev": { file: "kind.json", root: "$.events[?(@.name=='KindRegistered')].data.desc", field: "setRev" },
+    // set
+    "set.id": { file: "set.json", root: "$.events[?(@.name=='SetRegistered')].data", field: "id" },
+    "set.rev": { file: "set.json", root: "$.events[?(@.name=='SetRegistered')].data.desc", field: "rev" },
+    "set.krev": { file: "set.json", root: "$.events[?(@.name=='SetRegistered')].data.desc", field: "kindRev" },
+    "set.srev": { file: "set.json", root: "$.events[?(@.name=='SetRegistered')].data.desc", field: "setRev" },
+    // matter: first entry’s MatterRegistered by default
+    "matter.hash": { file: "matter.json", root: "$[0].events[?(@.event=='MatterRegistered')].data", field: "1" },
+    "matter.who": { file: "matter.json", root: "$[0].events[?(@.event=='MatterRegistered')].data", field: "0" },
+};
+function dynamicRule(key) {
+    const esc = (s) => s.replace(/'/g, "\\'");
+    // hash=<path>  → hashes.json: find by .path and return .hash
+    {
+        const m = key.match(/^hash=(.+)$/);
+        if (m) {
+            const filePath = esc(m[1]);
+            return {
+                file: "hashes.json",
+                root: `$[?(@.path=='${filePath}')]`,
+                field: "hash",
+            };
+        }
+    }
+    // matter.hash=<path> → matter.json: find entry by .file, then MatterRegistered.data[1]
+    {
+        const m = key.match(/^matter\.hash=(.+)$/);
+        if (m) {
+            const filePath = esc(m[1]);
+            return {
+                file: "matter.json",
+                root: `$[?(@.file=='${filePath}')].events[?(@.event=='MatterRegistered')].data`,
+                field: "1",
+            };
+        }
+    }
+    // matter.who=<path> → matter.json: find entry by .file, then MatterRegistered.data[0]
+    {
+        const m = key.match(/^matter\.who=(.+)$/);
+        if (m) {
+            const filePath = esc(m[1]);
+            return {
+                file: "matter.json",
+                root: `$[?(@.file=='${filePath}')].events[?(@.event=='MatterRegistered')].data`,
+                field: "0",
+            };
+        }
+    }
+    return null;
+}
+function resolveRule(key) {
+    let rule = dynamicRule(key);
+    if (rule)
+        return rule;
+    rule = STATIC_RULES[key];
+    if (!rule)
+        throw new Error(`Unknown key: ${key}`);
+    return rule;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function pickOnce(getData, key) {
+    const rule = resolveRule(key);
+    const data = getData(rule.file);
+    const roots = jp.query(data, rule.root);
+    if (roots.length === 0) {
+        throw new Error(`Root not found for key "${key}": ${rule.root} in ${rule.file}`);
+    }
+    // Pick the first matched root
+    const obj = roots[0];
+    const value = rule.field ? _.get(obj, rule.field) : obj;
+    if (value === undefined) {
+        throw new Error(`Field not found for key "${key}": ${rule.field} in ${rule.file}`);
+    }
+    return String(value);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function loadJson(fullPath) {
+    const raw = fs.readFileSync(fullPath, "utf8");
+    return JSON.parse(raw);
+}
+export const pickCmd = new Command("pick")
+    .description("Pick values from outputs")
+    .argument("<keys...>", "Keys to resolve")
+    .option("--from <dir>", "Output directory", DEFAULT_DIR)
+    .action(function (keys) {
+    const { from } = this.opts();
+    const dir = from || DEFAULT_DIR;
+    const loadJsonCache = _.memoize((rel) => {
+        const full = path.join(dir, rel);
+        return loadJson(full);
+    });
+    const outputs = keys.map((key) => pickOnce(loadJsonCache, key));
+    console.log(outputs.join(" "));
+});

package/dist/index.js

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

package/dist/parsers.js

@@ -9,6 +9,17 @@ export function parseBigInt(arg) {
         throw new InvalidArgumentError("invalid bigint");
     }
 }
+export function parseSID(arg) {
+    try {
+        const [s, i] = arg.split(".");
+        const set = BigInt(s);
+        const id = BigInt(i);
+        return { set, id };
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError(`invalid SID: ${arg}`);
+    }
+}
 export function parseAccountId(address) {
     try {
         return u8aFixLength(decodeAddress(address), 256);

package/dist/program.js

@@ -12,6 +12,7 @@ import { setCmd } from "./cmds/set.js";
 import { objectCmd } from "./cmds/object.js";
 import { minterCmd } from "./cmds/minter.js";
 import { universeCmd } from "./cmds/universe.js";
+import { pickCmd } from "./cmds/pick.js";
 export const program = new Command("every")
     .description("CLI for interacting with Every Protocol")
     .version(version())
@@ -27,4 +28,5 @@ export const program = new Command("every")
     .addCommand(minterCmd)
     .addCommand(balanceCmd)
     .addCommand(walletCmd)
-    .addCommand(configCmd);
+    .addCommand(configCmd)
+    .addCommand(pickCmd, { hidden: true });

package/dist/utils.js

@@ -4,7 +4,7 @@ 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 { getAddress, isAddress, pad, sha256 } from "viem";
+import { getAddress, isAddress } from "viem";
 import { FromOpts } from "./from-opts.js";
 export const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function version() {
@@ -167,18 +167,3 @@ 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)");
-    }
-    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.4",
+  "version": "0.1.6",
   "files": [
     "dist/",
     "abis/",
@@ -16,6 +16,7 @@
     "@eslint/js": "^9.26.0",
     "@types/bun": "latest",
     "@types/columnify": "^1.5.4",
+    "@types/jsonpath": "^0.2.4",
     "@types/lodash-es": "^4.17.12",
     "@types/prompt-sync": "^4.2.3",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
@@ -35,9 +36,11 @@
     "@polkadot/util-crypto": "^13.5.2",
     "columnify": "^1.6.0",
     "commander": "^13.1.0",
+    "csv-parser": "^3.2.0",
     "ethers": "^6.14.0",
     "json11": "^2.0.2",
     "json5": "^2.2.3",
+    "jsonpath": "^1.1.1",
     "lodash-es": "^4.17.21",
     "prompt-sync": "^4.2.0",
     "viem": "^2.29.1"