@everyprotocol/every-cli 0.1.6 → 0.1.8

package/dist/cmdgen.js

@@ -10,7 +10,7 @@ const getReadAction = (config, funName, abiFunc, abi) => async function readActi
     const opts = this.opts();
     const conf = FromOpts.getUniverseConfig(opts);
     const address = await config.getContract(conf, this.processedArgs, abiFunc);
-    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.processedArgs, abiFunc);
+    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.processedArgs, abiFunc, opts);
     const console = new Logger(opts);
     const publicClient = createPublicClient({ transport: http(conf.rpc) });
     const result = await publicClient.readContract({ address, abi, functionName: funName, args });
@@ -20,7 +20,7 @@ const getReadAction = (config, funName, abiFunc, abi) => async function readActi
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getWriteAction = (config, funcName, abiFunc, abi) => async function writeAction() {
     const opts = this.opts();
-    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.args, abiFunc);
+    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.args, abiFunc, opts);
     const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
     const address = config.getContract(conf, this.args, abiFunc);
     const account = walletClient.account;
@@ -36,7 +36,8 @@ export const getCommandGen = (config) => function genCmd(cmdName) {
     const abiFuncDoc = abiFuncs[0];
     const description = abiFuncDoc._metadata?.notice || "";
     const isRead = abiFuncDoc.stateMutability == "view" || abiFuncDoc.stateMutability == "pure";
-    const options = isRead ? [universe, ...outputOptions] : [...writeOptions, ...outputOptions];
+    // const options = isRead ? [universe, ...outputOptions] : [...writeOptions, ...outputOptions];
+    const options = (config.getCmdOpts ?? CommandGenDefaults.getCmdOpts)(abiFuncDoc);
     const args = (config.getCmdArgs ?? CommandGenDefaults.getCmdArgs)(abiFuncDoc);
     const abiContract = [...abiFuncs, ...abiNonFuncs];
     const action = isRead
@@ -48,7 +49,12 @@ export function makeFuncName(cmdName, prefix) {
     return `${prefix}${cmdName[0].toUpperCase()}${cmdName.slice(1)}`;
 }
 export const CommandGenDefaults = {
-    getFuncArgs: (args, abiFunc) => args.map((arg, i) => coerceValue(arg, abiFunc.inputs[i])),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+    getFuncArgs: (args, abiFunc, opts) => args.map((arg, i) => coerceValue(arg, abiFunc.inputs[i])),
+    getCmdOpts: (abiFunc) => {
+        const isRead = abiFunc.stateMutability == "view" || abiFunc.stateMutability == "pure";
+        return isRead ? [universe, ...outputOptions] : [...writeOptions, ...outputOptions];
+    },
     getCmdArgs: (abiFunc) => abiFunc.inputs.map((input) => {
         const desc = abiFunc._metadata?.params?.[input.name] || `${input.type} parameter`;
         return new Argument(`<${input.name}>`, desc);

package/dist/cmds/kind.js

@@ -1,14 +1,132 @@
-import { Command } from "commander";
+import { Argument, Command, Option } from "commander";
 import { abi } from "../abi.js";
 import { getCommandGen, makeFuncName } from "../cmdgen.js";
-const cmdGenConfig = {
+import { toHex } from "viem";
+import { coerceValue, readKindElements, toElementType, toRelationId } from "../utils.js";
+import { outputOptions, writeOptions } from "../commander-patch.js";
+import { submitSimulation } from "../ethereum.js";
+import { Logger } from "../logger.js";
+import { FromOpts } from "../from-opts.js";
+const genKindCmd = getCommandGen({
     getFuncName: (cmdName) => makeFuncName(cmdName, `kind`),
     getAbiFuncs: (funcName) => abi.funcs.kindRegistry.filter((i) => i.name == funcName),
     // eslint-disable-next-line
     getAbiNonFuncs: (funcName) => abi.nonFuncs.kindRegistry,
     // eslint-disable-next-line
     getContract: (conf, args, abiFunc) => conf.contracts.KindRegistry,
-};
-const cmdGen = getCommandGen(cmdGenConfig);
-const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot".split(",");
-export const kindCmd = new Command("kind").description("manage kinds").addCommands(subCmds.map(cmdGen));
+});
+const registerCmd = genRegisterCmd();
+const updateCmd = genUpdateCmd();
+const otherCmds = "upgrade,touch,transfer,owner,descriptor,snapshot".split(",").map(genKindCmd);
+export const kindCmd = new Command("kind")
+    .description("manage kinds")
+    .addCommand(registerCmd)
+    .addCommand(updateCmd)
+    .addCommands(otherCmds);
+function genRegisterCmd() {
+    const funcName = "kindRegister";
+    const abiFuncs = abi.funcs.kindRegistry.filter((i) => i.name == funcName);
+    const abiNonFuncs = abi.nonFuncs.kindRegistry;
+    const code = new Argument("<code>", "Matter hash of the kind code");
+    const data = new Argument("<data>", "Matter hash of the kind data");
+    const etys = new Option("--elements <ety...>", "Element types");
+    const rels = new Option("--relations <rel...>", "IDs of relations supported");
+    const options = [etys, rels, ...writeOptions, ...outputOptions];
+    const args = [code, data];
+    function resolveElementTypes(args) {
+        return args.length == 0
+            ? []
+            : args.length == 1 && /\.wasm$/i.test(args[0])
+                ? readKindElements(args[0])
+                : args.map(toElementType);
+    }
+    function getFuncArgs(cmd) {
+        const opts = cmd.opts();
+        const etys = resolveElementTypes(opts.elements ?? []);
+        const rels = (opts.relations ?? []).map(toRelationId);
+        const args = cmd.args.map((arg, i) => coerceValue(arg, abiFuncs[0].inputs[i]));
+        args.push(etys, rels);
+        return args;
+    }
+    async function getCmdAction(cmd) {
+        const opts = cmd.opts();
+        const args = getFuncArgs(cmd);
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const address = conf.contracts.KindRegistry;
+        const account = walletClient.account;
+        const simulation = {
+            address,
+            abi: [...abiFuncs, ...abiNonFuncs],
+            functionName: funcName,
+            args,
+            account,
+        };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("register")
+        .description("Register a new kind")
+        .addOptions(options)
+        .addArguments(args)
+        .action(getCmdAction);
+}
+function genUpdateCmd() {
+    const funcName = "kindUpdate";
+    const abiFuncs = abi.funcs.kindRegistry.filter((i) => i.name == funcName);
+    const abiNonFuncs = abi.nonFuncs.kindRegistry;
+    const code = new Option("--code <code>", "Matter hash of the kind code");
+    const data = new Option("--data <data>", "Matter hash of the kind data");
+    const rels = new Option("--relations [rel...]", "IDs of relations supported");
+    const id = new Argument(`<id>`, "Kind id");
+    const options = [code, data, rels, ...writeOptions, ...outputOptions];
+    const args = [id];
+    function getFuncArgs(cmd) {
+        const opts = cmd.opts();
+        const args = [cmd.args[0]];
+        const ZERO32 = toHex(0, { size: 32 });
+        let sig;
+        if (opts.relations) {
+            if (opts.code || opts.data) {
+                sig = "kindUpdate(uint64,bytes32,bytes32,uint64[])";
+                args.push(opts.code ?? ZERO32);
+                args.push(opts.data ?? ZERO32);
+                args.push(typeof opts.relations == "boolean" ? [] : opts.relations);
+            }
+            else {
+                sig = "kindUpdate(uint64,uint64[])";
+                args.push(typeof opts.relations == "boolean" ? [] : opts.relations);
+            }
+        }
+        else {
+            if (opts.code || opts.data) {
+                sig = "kindUpdate(uint64,bytes32,bytes32)";
+                args.push(opts.code ?? ZERO32);
+                args.push(opts.data ?? ZERO32);
+            }
+            else {
+                throw new Error("");
+            }
+        }
+        const abiFunc = abiFuncs.filter((f) => f._metadata.signature == sig)[0];
+        return [args, abiFunc];
+    }
+    async function getCmdAction(cmd) {
+        const opts = cmd.opts();
+        const [args, abiFunc] = getFuncArgs(cmd);
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const address = conf.contracts.KindRegistry;
+        const account = walletClient.account;
+        const simulation = {
+            address,
+            abi: [abiFunc, ...abiNonFuncs],
+            functionName: "kindUpdate",
+            args,
+            account,
+        };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("update")
+        .description("Update an existing kind")
+        .addOptions(options)
+        .addArguments(args)
+        .action(getCmdAction);
+}

package/dist/cmds/matter.js

@@ -229,13 +229,24 @@ async function compileEnumMatter(file) {
             throw new Error(`Invalid column element type: ${h}`);
         }
     };
+    function resolvePath(v) {
+        if (path.isAbsolute(v))
+            return v;
+        const dir = path.dirname(file);
+        if (path.isAbsolute(file)) {
+            return path.resolve(dir, v);
+        }
+        else {
+            return path.normalize(path.join(dir, v));
+        }
+    }
     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);
+            const { hash, mime, form, path } = computeHashMemo(resolvePath(v));
             if (!deps.has(path)) {
                 deps.set(path, { hash, mime, form, path });
             }
@@ -261,7 +272,7 @@ async function compileEnumMatter(file) {
             .on("end", () => {
             const auxTypes = Object.keys(aux ?? {});
             const auxValues = Object.values(aux ?? {});
-            const enumHeader = buildEnumHeader(auxTypes, colTypes, rows);
+            const enumHeader = buildEnumHeader(auxTypes ?? [], colTypes ?? [], rows);
             resolve(Buffer.concat([enumHeader, ...auxValues, ...content]));
         })
             .on("error", (e /* eslint-disable-line */) => {
@@ -318,22 +329,24 @@ function computeHashFile(file) {
  *   [16..31] = col_types [u8; 16]
  */
 function buildEnumHeader(auxTypes, colTypes, rows = 0) {
-    if (colTypes.length === 0 && auxTypes.length === 0) {
+    const colTypesLen = colTypes.length;
+    const auxTypesLen = auxTypes.length;
+    if (colTypesLen + auxTypesLen == 0) {
         throw new Error("Empty header list");
     }
-    if (auxTypes.length > 8) {
-        throw new Error(`Too many aux types (max 8): ${auxTypes.length}`);
+    if (auxTypesLen > 8) {
+        throw new Error(`Too many aux types (max 8): ${auxTypesLen}`);
     }
-    if (colTypes.length > 16) {
-        throw new Error(`Too many column types (max 16): ${colTypes.length}`);
+    if (colTypesLen > 16) {
+        throw new Error(`Too many column types (max 16): ${colTypesLen}`);
     }
     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[4] = (0x01 << 4) | (auxTypesLen & 0x0f); // version(hi4), aux(lo4)
+    buf[5] = colTypesLen; // 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

package/dist/cmds/pick.js

@@ -3,14 +3,22 @@ import path from "node:path";
 import jp from "jsonpath";
 import * as _ from "lodash-es";
 import { Command } from "commander";
+import { loadMergedConfig } from "../config.js";
 const DEFAULT_DIR = "./register";
+const DEFAULT_UNIVERSE = "anvil";
 const STATIC_RULES = {
+    // config
+    "universe.id": { file: "config://universe.json", root: "$", field: "id" },
+    "universe.sreg": { file: "config://universe.json", root: "$", field: "contracts.SetRegistry" },
+    "universe.oreg": { file: "config://universe.json", root: "$", field: "contracts.OmniRegistry" },
+    "universe.kreg": { file: "config://universe.json", root: "$", field: "contracts.KindRegistry" },
+    "universe.ereg": { file: "config://universe.json", root: "$", field: "contracts.ElementRegistry" },
+    "universe.minter": { file: "config://universe.json", root: "$", field: "contracts.ObjectMinter" },
+    "universe.rpc": { file: "config://universe.json", root: "$", field: "rpc" },
+    "universe.observer": { file: "config://universe.json", root: "$", field: "observer" },
     // contract
-    "deploy.addr": {
-        file: "deploy.json",
-        root: "$",
-        field: "deployedTo",
-    },
+    "deploy.addr": { file: "deploy.json", root: "$", field: "deployedTo" },
+    "contract.addr": { file: "contract.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" },
@@ -99,13 +107,24 @@ export const pickCmd = new Command("pick")
     .description("Pick values from outputs")
     .argument("<keys...>", "Keys to resolve")
     .option("--from <dir>", "Output directory", DEFAULT_DIR)
+    .option("-u, --universe <name>", "Universe name", DEFAULT_UNIVERSE)
     .action(function (keys) {
-    const { from } = this.opts();
-    const dir = from || DEFAULT_DIR;
+    const { from, universe } = this.opts();
     const loadJsonCache = _.memoize((rel) => {
-        const full = path.join(dir, rel);
+        if (rel == "config://universe.json") {
+            return loadUniverseConfig(universe);
+        }
+        const full = path.join(from, rel);
         return loadJson(full);
     });
     const outputs = keys.map((key) => pickOnce(loadJsonCache, key));
     console.log(outputs.join(" "));
 });
+function loadUniverseConfig(universe) {
+    const config = loadMergedConfig();
+    const uniConf = config.universes?.[universe];
+    if (!uniConf) {
+        throw new Error(`config for universe ${universe} not found`);
+    }
+    return uniConf;
+}

package/dist/commander-patch.js

@@ -7,11 +7,10 @@ export const privateKey = new Option("-k, --private-key <key>", "Private key to
 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 json = new Option("-j, --json [file]", "Output result as JSON to stdout or file");
 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 outputOptions = [json, quiet];
 export const writeOptions = [universe, account, password, passwordFile, foundry];
 Command.prototype.addCommands = function (commands) {
     commands.forEach((cmd) => this.addCommand(cmd));
@@ -29,7 +28,7 @@ Command.prototype.addKeystoreOptions = function () {
     return this.addOptions([account, password, passwordFile, foundry]);
 };
 Command.prototype.addOutputOptions = function () {
-    return this.addOptions([json, quiet, noQuiet]);
+    return this.addOptions([json, quiet]);
 };
 Command.prototype.addWriteOptions = function () {
     return this.addKeystoreOptions().addOption(universe);

package/dist/logger.js

@@ -5,7 +5,7 @@ export class Logger {
     quiet;
     json;
     constructor(opts = {}) {
-        this.quiet = opts.quiet ?? !!opts.json;
+        this.quiet = opts.quiet ?? false;
         this.json = opts.json ?? false;
     }
     log(...args) {

package/dist/utils.js

@@ -167,3 +167,26 @@ export function loadBinary(file) {
     const buf = fs.readFileSync(file);
     return buf;
 }
+export function readKindElements(file) {
+    const buf = fs.readFileSync(file);
+    const mod = new WebAssembly.Module(buf); // sync
+    const [section] = WebAssembly.Module.customSections(mod, "kindelms");
+    if (!section)
+        throw new Error(`Section "kindelms" not found in ${file}`);
+    return Array.from(new Uint8Array(section));
+}
+export function toElementType(v) {
+    const n = typeof v === "number" ? v : v.startsWith("0x") ? Number.parseInt(v.slice(2), 16) : Number.parseInt(v, 10);
+    if (!Number.isInteger(n) || n < 1 || n > 255) {
+        throw new Error(`Invalid element type: ${v} (must be 1–255)`);
+    }
+    return n;
+}
+export function toRelationId(v) {
+    const n = typeof v === "bigint" ? v : BigInt(v);
+    const U48_MAX = (1n << 48n) - 1n;
+    if (n < 1n || n > U48_MAX) {
+        throw new Error(`Invalid relation id: ${String(v)} (must be between 1 and ${U48_MAX})`);
+    }
+    return n;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "files": [
     "dist/",
     "abis/",