@everyprotocol/every-cli 0.1.8 → 0.1.9

package/dist/cmdgen.js

@@ -25,6 +25,7 @@ const getWriteAction = (config, funcName, abiFunc, abi) => async function writeA
     const address = config.getContract(conf, this.args, abiFunc);
     const account = walletClient.account;
     const simulation = { address, abi, functionName: funcName, args, account };
+    console.log({ address, functionName: funcName, args, account });
     await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
 };
 export const getCommandGen = (config) => function genCmd(cmdName) {

package/dist/cmds/matter.js

@@ -1,16 +1,13 @@
 import { Command } from "commander";
 import "@polkadot/api-augment/substrate";
 import * as fs from "fs";
-import * as JSON11 from "json11";
+import path from "path";
 import columify from "columnify";
-import { loadBinary, loadJson } from "../utils.js";
+import { j11String, 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";
+import { compileEnumCsv, compilePermCsv, computeHash, parseFileSpec, specToInput, } from "../matter.js";
 const matterRegisterCmd = new Command("register")
     .description("Register matters")
     .argument("<files...>", "Paths of matter blob files")
@@ -24,7 +21,7 @@ const matterRegisterCmd = new Command("register")
     const inputs = [];
     for (const file of files) {
         const spec = parseFileSpec(file);
-        const mi = await toRegisterInput(spec);
+        const mi = await specToInput(spec);
         mi.forEach((input) => {
             if (!deduper.has(input.path)) {
                 inputs.push(input);
@@ -52,7 +49,7 @@ const matterRegisterCmd = new Command("register")
         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())]);
+        const events = r.events.map((e) => [e.event.method, j11String(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 }));
@@ -97,7 +94,7 @@ const matterHashCmd = new Command("hash")
     const outputs = [];
     for (const file of files) {
         const spec = parseFileSpec(file);
-        const inputs = await toRegisterInput(spec);
+        const inputs = await specToInput(spec);
         inputs.forEach((input) => {
             if (!seen.has(input.path)) {
                 seen.add(input.path);
@@ -135,311 +132,21 @@ export const matterCmd = new Command("matter")
     .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 };
+        return { binFile, depsFile, outDir: dir, compile: compileEnumCsv };
     }
     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 };
+        return { binFile, depsFile, outDir: dir, compile: compilePermCsv };
     }
     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}`);
-        }
-    };
-    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(resolvePath(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) {
-    const colTypesLen = colTypes.length;
-    const auxTypesLen = auxTypes.length;
-    if (colTypesLen + auxTypesLen == 0) {
-        throw new Error("Empty header list");
-    }
-    if (auxTypesLen > 8) {
-        throw new Error(`Too many aux types (max 8): ${auxTypesLen}`);
-    }
-    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) | (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
-    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/relation.js

@@ -1,7 +1,15 @@
-import { Command } from "commander";
+import { Argument, Command, Option } from "commander";
+import { pad, padHex } from "viem";
+import fs from "node:fs";
 import { abi } from "../abi.js";
 import { getCommandGen, makeFuncName } from "../cmdgen.js";
-const cmdGenConfig = {
+import { coerceValue, j11Parse, stringify } 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";
+import { parseEnum, RelationOwnerShift, RelationTerminator } from "../enums.js";
+const genRelationCmd = getCommandGen({
     getFuncName: (cmdName) => makeFuncName(cmdName, `relation`),
     getAbiFuncs: (funcName) => abi.funcs.omniRegistry.filter((i) => i.name == funcName),
     // eslint-disable-next-line
@@ -10,7 +18,137 @@ const cmdGenConfig = {
     getContract: (conf, args, abiFunc) => conf.contracts.OmniRegistry,
     // eslint-disable-next-line
     getFuncArgs: (args, abiFunc) => args,
-};
-const cmdGen = getCommandGen(cmdGenConfig);
-const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot,rule,admit".split(",");
-export const relationCmd = new Command("relation").description("manage relations").addCommands(subCmds.map(cmdGen));
+});
+const registerCmd = genRegisterCmd();
+const updateCmd = genUpdateCmd();
+const otherCmds = "upgrade,touch,transfer,owner,descriptor,snapshot,rule,admit".split(",").map(genRelationCmd);
+export const relationCmd = new Command("relation")
+    .description("manage relations")
+    .addCommand(registerCmd)
+    .addCommand(updateCmd)
+    .addCommands(otherCmds);
+function genRegisterCmd() {
+    const funcName = "relationRegister";
+    const abiFuncs = abi.funcs.omniRegistry.filter((i) => i.name == funcName);
+    const abiNonFuncs = abi.nonFuncs.omniRegistry;
+    const data = new Argument("<data>", "Matter hash of the relation data");
+    const rule = new Argument("<rule>", "Relation rule");
+    const adjs = new Argument("<adjs...>", "Relation adjacencies");
+    const options = [...writeOptions, ...outputOptions];
+    const args = [data, rule, adjs];
+    function getFuncArgs(cmd) {
+        const code = pad("0x", { size: 20 });
+        const data = cmd.processedArgs[0];
+        const rule = stringify(resolveRule(cmd.processedArgs[1]));
+        const adjs = stringify(resolveAdjs(cmd.processedArgs[2]));
+        const args = [code, data, rule, adjs].map((arg, i) => coerceValue(arg, abiFuncs[0].inputs[i]));
+        return args;
+    }
+    async function getCmdAction() {
+        const opts = this.opts();
+        const args = getFuncArgs(this);
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const address = conf.contracts.OmniRegistry;
+        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 relation")
+        .addOptions(options)
+        .addArguments(args)
+        .action(getCmdAction);
+}
+function genUpdateCmd() {
+    const funcName = "relationUpdate";
+    const abiFuncs = abi.funcs.omniRegistry.filter((i) => i.name == funcName);
+    // console.log(abiFuncs);
+    const abiNonFuncs = abi.nonFuncs.omniRegistry;
+    const rel = new Argument("<rel>", "Relation ID");
+    const data = new Argument("<data>", "Matter hash of the relation data");
+    const adjs = new Option("--adjs <adjacency...>", "Relation adjacencies");
+    const options = [adjs, ...writeOptions, ...outputOptions];
+    const args = [rel, data];
+    function getFuncArgs(cmd) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const opts = cmd.opts();
+        let args = [cmd.processedArgs[0], cmd.processedArgs[1]];
+        let sig = "relationUpdate(uint64,bytes32)";
+        if (opts.adjs) {
+            sig = "relationUpdate(uint64,bytes32,(uint16,uint48)[])";
+            const adjs = stringify(resolveAdjs(opts.adjs));
+            args.push(adjs);
+        }
+        const abiFunc = abiFuncs.find((i) => i._metadata.signature == sig);
+        if (!abiFunc) {
+            throw new Error(`signature ${sig} not found in abi`);
+        }
+        args = args.map((arg, i) => coerceValue(arg, abiFunc.inputs[i]));
+        return { args, sig, abiFunc };
+    }
+    async function getCmdAction() {
+        const opts = this.opts();
+        const { args } = getFuncArgs(this);
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const address = conf.contracts.OmniRegistry;
+        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("update")
+        .description("Update an existing relation")
+        .addOptions(options)
+        .addArguments(args)
+        .action(getCmdAction);
+}
+const U48_MAX = (1n << 48n) - 1n;
+const DEG_MAX = 0x7fff;
+const AT_LEAST_ONE_FLAG = 0x8000;
+function resolveAdjs(args) {
+    const kind = (s) => {
+        if (/^other$/i.test(s))
+            return 0n;
+        if (/^total$/i.test(s))
+            return U48_MAX;
+        const n = BigInt(s);
+        if (n < 0n || n > U48_MAX)
+            throw new Error("kind out of range");
+        return n;
+    };
+    const degs = (s) => {
+        const plus = s.endsWith("+"), t = plus ? s.slice(0, -1) : s, n = Number(t);
+        if (!/^\d+$/.test(t) || n < 0 || n > DEG_MAX)
+            throw new Error("degs out of range");
+        return plus ? n | AT_LEAST_ONE_FLAG : n;
+    };
+    return args.map((s) => {
+        const [k, d] = s.split(":");
+        if (!k || !d)
+            throw new Error(`bad "${s}"`);
+        return { kind: kind(k.trim()), degs: degs(d.trim()) };
+    });
+}
+function resolveRule(arg) {
+    const json = arg.startsWith("@") ? fs.readFileSync(arg.slice(1), "utf8") : arg;
+    const input = j11Parse(json);
+    return {
+        version: input.version ?? 1,
+        relateShift: parseEnum(input.relateShift, RelationOwnerShift, "relateShift"),
+        terminator: parseEnum(input.terminator, RelationTerminator, "terminator"),
+        unrelateShift: parseEnum(input.unrelateShift, RelationOwnerShift, "unrelateShift"),
+        unrelateDelay: input.unrelateDelay ?? 0,
+        extra: padHex(input.extra ?? "0x", { size: 20 }),
+    };
+}

package/dist/enums.js

@@ -0,0 +1,41 @@
+export var RelationTerminator;
+(function (RelationTerminator) {
+    RelationTerminator[RelationTerminator["TailOwner"] = 0] = "TailOwner";
+    RelationTerminator[RelationTerminator["HeadOwner"] = 1] = "HeadOwner";
+    RelationTerminator[RelationTerminator["Either"] = 2] = "Either";
+    RelationTerminator[RelationTerminator["Neither"] = 3] = "Neither";
+    RelationTerminator[RelationTerminator["Anyone"] = 4] = "Anyone";
+    RelationTerminator[RelationTerminator["Nobody"] = 5] = "Nobody";
+})(RelationTerminator || (RelationTerminator = {}));
+export var RelationOwnerShift;
+(function (RelationOwnerShift) {
+    RelationOwnerShift[RelationOwnerShift["Retain"] = 0] = "Retain";
+    RelationOwnerShift[RelationOwnerShift["TransferToTailOwner"] = 1] = "TransferToTailOwner";
+    RelationOwnerShift[RelationOwnerShift["TransferToHeadOwner"] = 2] = "TransferToHeadOwner";
+    RelationOwnerShift[RelationOwnerShift["TransferToCaller"] = 3] = "TransferToCaller";
+    RelationOwnerShift[RelationOwnerShift["TransferToPreset"] = 4] = "TransferToPreset";
+    RelationOwnerShift[RelationOwnerShift["TransferToBurned"] = 5] = "TransferToBurned";
+    RelationOwnerShift[RelationOwnerShift["TransferToResolved"] = 6] = "TransferToResolved";
+    RelationOwnerShift[RelationOwnerShift["TransferToIntended"] = 7] = "TransferToIntended";
+    RelationOwnerShift[RelationOwnerShift["HoldForTailOwner"] = 8] = "HoldForTailOwner";
+    RelationOwnerShift[RelationOwnerShift["HoldForHeadOwner"] = 9] = "HoldForHeadOwner";
+    RelationOwnerShift[RelationOwnerShift["HoldForCaller"] = 10] = "HoldForCaller";
+    RelationOwnerShift[RelationOwnerShift["HoldForPreset"] = 11] = "HoldForPreset";
+    RelationOwnerShift[RelationOwnerShift["HoldForBurned"] = 12] = "HoldForBurned";
+    RelationOwnerShift[RelationOwnerShift["HoldForResolved"] = 13] = "HoldForResolved";
+    RelationOwnerShift[RelationOwnerShift["HoldPending"] = 14] = "HoldPending";
+})(RelationOwnerShift || (RelationOwnerShift = {}));
+export function parseEnum(v, E, name) {
+    if (typeof v === "number") {
+        if (v in E)
+            return v;
+    }
+    else if (typeof v === "string") {
+        // accept exact key or case-insensitive key
+        const k = Object.keys(E).find((key) => key.toLowerCase() === v.toLowerCase());
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (k && typeof E[k] === "number")
+            return E[k];
+    }
+    throw new Error(`${name} must be a valid enum value or key`);
+}

package/dist/matter.js

@@ -0,0 +1,479 @@
+import * as fs from "fs";
+import { loadBinary, loadJson } from "./utils.js";
+import path from "path";
+import csv from "csv-parser";
+import { fromHex, pad, sha256 } from "viem";
+import { memoize } from "lodash-es";
+const MATTER_FORMS = {
+    // Simple
+    JSON: 0x01,
+    IMAGE: 0x02,
+    // Code
+    WASM: 0xc0,
+    // Data
+    ENUM: 0xd0,
+    PERM: 0xd1,
+    // Info
+    INFO: 0xff,
+};
+const CELL_TYPES = {
+    JSON: 0x01,
+    IMAGE: 0x02,
+    INFO: 0xff,
+};
+export function formValueByName(name) {
+    const value = MATTER_FORMS[name];
+    if (value === undefined) {
+        throw new Error(`Invalid form name: "${name}"`);
+    }
+    return value;
+}
+export function metaFromExt(file) {
+    const ext = path.extname(file);
+    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 (file.endsWith(".enum.bin")) {
+                return { mime: "application/vnd.every.enum", form: MATTER_FORMS.ENUM };
+            }
+            else if (file.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");
+    }
+}
+export 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);
+}
+export function computeHashFromFile(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 = metaFromExt(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 };
+}
+export 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 };
+}
+export async function specToInput(spec) {
+    if (spec.type == "blob") {
+        if (spec.form && spec.mime)
+            return [{ path: spec.path, form: spec.form, mime: spec.mime }];
+        const meta = metaFromExt(spec.path);
+        return [{ path: spec.path, form: spec.form ?? meta.form, mime: spec.mime ?? meta.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 compileEnumCsv(spec.path);
+            const path = spec.path.slice(0, -9) + ".enum.bin";
+            const { form, mime } = metaFromExt(path);
+            return [...deps, { blob, form, mime, path }];
+        }
+        else if (spec.path.endsWith(".perm.csv")) {
+            const { blob, deps } = await compilePermCsv(spec.path);
+            const path = spec.path.slice(0, -9) + ".perm.bin";
+            const { form, mime } = metaFromExt(path);
+            return [...deps, { blob, form, mime, path }];
+        }
+        else {
+            throw new Error("unknown raw matter file extension");
+        }
+    }
+    else {
+        throw new Error("unknown matter file type");
+    }
+}
+export async function compileEnumCsv(csvFile) {
+    const deps = new Map();
+    const hashCellFileMemo = HashCellFileMemo(csvFile, deps);
+    const mapHeaders = ({ header }) => parseCsvHeader(header);
+    const mapValues = ({ header, value }) => {
+        const c = parseCsvCell(value, header);
+        if (c.type == "hex") {
+            const bin = fromHex(pad(c.hex, { size: 32, dir: "left" }), "bytes");
+            return bin;
+        }
+        else if (c.type == "file") {
+            const input = hashCellFileMemo(c.file);
+            const bin = fromHex(input.hash, "bytes");
+            return bin;
+        }
+    };
+    const aux = parseCsvAux(csvFile, hashCellFileMemo);
+    const rows = [];
+    const headers = [];
+    const blob = await new Promise((resolve, reject) => {
+        fs.createReadStream(csvFile)
+            .pipe(csv({ skipComments: true, strict: true, mapHeaders, mapValues }))
+            .on("error", (e) => reject(e))
+            .on("headers", (hs) => headers.push(...hs))
+            .on("data", (data) => rows.push(Object.values(data)))
+            .on("end", () => {
+            const auxTypes = Object.keys(aux ?? {});
+            const auxData = Object.values(aux ?? {});
+            const header = buildEnumBinHeader(auxTypes ?? [], headers, rows.length);
+            resolve(Buffer.concat([header, ...auxData, ...rows.flat()]));
+        });
+    });
+    return { blob, deps: Array.from(deps.values()) };
+}
+export async function compilePermCsv(csvFile) {
+    const deps = new Map();
+    const hashCellFileMemo = HashCellFileMemo(csvFile, deps);
+    const headers = [];
+    const columns = [];
+    const mapHeaders = (header) => {
+        const h = parsePermCsvHeader(header);
+        headers.push(h);
+        return h.header;
+    };
+    const mapValues = ({ header, value, index }) => {
+        const v = parsePermCsvCell(value, header);
+        const bin = v.type == "hex"
+            ? fromHex(pad(v.hex, { size: 32, dir: "left" }), "bytes")
+            : v.type == "file"
+                ? fromHex(hashCellFileMemo(v.file).hash, "bytes")
+                : null;
+        if (bin)
+            for (let i = 0; i < v.count; i++)
+                columns[index].push(bin);
+        return v.cell;
+    };
+    const aux = parseCsvAux(csvFile, hashCellFileMemo);
+    const blob = await new Promise((resolve, reject) => {
+        fs.createReadStream(csvFile)
+            .pipe(csv({ skipComments: true, strict: false, mapHeaders, mapValues }))
+            .on("error", (e) => reject(e))
+            .on("headers", (hs) => hs.forEach(() => columns.push([])))
+            .on("data", (data) => void data) // event must be subscribed, so that "end" works
+            .on("end", () => {
+            validatePermColumns(headers, columns);
+            const auxTypes = Object.keys(aux ?? {});
+            const auxData = Object.values(aux ?? {});
+            const header = buildPermBinHeader(auxTypes, headers, columns);
+            resolve(Buffer.concat([header, ...auxData, ...columns.flat()]));
+        });
+    });
+    return { blob, deps: Array.from(deps.values()) };
+}
+function validatePermColumns(headers, columns) {
+    const n = headers.length;
+    if (n !== columns.length)
+        throw new Error("headers/columns length mismatch");
+    const sizes = columns.map((c) => c.length);
+    const permIdxs = headers.map((h, i) => (h.perm ? i : -1)).filter((i) => i >= 0);
+    const prod = permIdxs.reduce((acc, cur) => acc * sizes[cur], 1);
+    if (prod === 0)
+        throw new Error("column height cannot be zero for permutation columns");
+    const ensureAllEqual = (idxs, expected) => {
+        if (idxs.length === 0)
+            return;
+        const ref = expected ?? sizes[idxs[0]];
+        for (const i of idxs) {
+            if (sizes[i] !== ref) {
+                throw new Error(`column heights mismatch: column ${i} has ${sizes[i]} but expected ${ref}`);
+            }
+            if (sizes[i] === 0) {
+                throw new Error(`column height cannot be zero (column ${i})`);
+            }
+        }
+    };
+    const nonPermIdxs = headers.map((h, i) => (!h.perm ? i : -1)).filter((i) => i >= 0);
+    ensureAllEqual(nonPermIdxs, permIdxs.length === 0 ? undefined : prod);
+}
+/**
+ * Build an 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]
+ */
+export function buildEnumBinHeader(auxTypes, colTypes, rows = 0) {
+    const colTypesLen = colTypes.length;
+    const auxTypesLen = auxTypes.length;
+    if (colTypesLen + auxTypesLen == 0) {
+        throw new Error("Empty header list");
+    }
+    if (auxTypesLen > 8) {
+        throw new Error(`Too many aux types (max 8): ${auxTypesLen}`);
+    }
+    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) | (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] = formValueByName(t))); // aux types
+    colTypes.forEach((t, i) => (buf[16 + i] = formValueByName(t))); // col types
+    return buf;
+}
+/**
+ * Build a PermMatter header.
+ * Layout:
+ *   [0..3]   = "PERM"
+ *   [4]      = ver, aux (u8.hi4, u8.lo4)
+ *   [5]      = cols (u8)
+ *   [6..7]   = enum_cols (16 bits)
+ *   [8..15]  = aux_types [u8; 8]
+ *   [16..31] = col_types [u8; 16]
+ *   [32..64] = col_heights [u16; 16]
+ */
+export function buildPermBinHeader(auxTypes, headers, columns) {
+    if (auxTypes.length > 8) {
+        throw new Error(`Too many aux types (max 8): ${auxTypes.length}`);
+    }
+    if (headers.length > 16) {
+        throw new Error(`Too many column types (max 16): ${headers.length}`);
+    }
+    if (columns.length != headers.length) {
+        throw new Error(`Headers and columns mismatch`);
+    }
+    const buf = new Uint8Array(columns.length > 0 ? 64 : 32);
+    buf.set([0x50, 0x45, 0x52, 0x4d], 0); // magic "ENUM"
+    buf[4] = (0x01 << 4) | (auxTypes.length & 0x0f); // version(hi4), aux(lo4)
+    buf[5] = headers.length; // cols
+    const bits = headers.reduce((prev, current, i) => {
+        return prev | (!current.perm ? 1 << (15 - i) : 0);
+    }, 0);
+    buf[6] = bits & 0xff; // bits.lo
+    buf[7] = (bits >>> 8) & 0xff; // bits.hi
+    auxTypes.forEach((t, i) => (buf[8 + i] = formValueByName(t))); // aux types
+    headers.forEach((h, i) => (buf[16 + i] = formValueByName(h.header))); // col types
+    columns.forEach((c, i) => {
+        const loByte = c.length & 0xff;
+        const hiByte = (c.length >>> 8) & 0xff;
+        buf[32 + i * 2] = loByte;
+        buf[32 + i * 2 + 1] = hiByte;
+    });
+    return buf;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseCsvAux(filePath, hashCellFileMemo) {
+    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 = ({ header }) => parseCsvHeader(header);
+    const mapValues = ({ header, value }) => {
+        const c = parseCsvCell(value, header);
+        if (c.type == "hex") {
+            const bin = fromHex(pad(c.hex, { size: 32, dir: "left" }), "bytes");
+            return bin;
+        }
+        else {
+            const input = hashCellFileMemo(c.file);
+            const bin = fromHex(input.hash, "bytes");
+            return bin;
+        }
+    };
+    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;
+}
+function parseCsvHeader(header) {
+    const h = header.trim().toUpperCase();
+    if (h in CELL_TYPES) {
+        return h;
+    }
+    else {
+        throw new Error(`Invalid element type: ${h}`);
+    }
+}
+function parseCsvCell(input, header) {
+    const cell = input.trim();
+    if (cell.length == 0)
+        throw new Error("empty cell not permitted");
+    // (0xHEX | FILE) [* NUMBER] with optional spaces around *
+    const re = /^(?:(0x[0-9A-Fa-f]+)|([^\s*]+))$/;
+    const m = cell.match(re);
+    if (!m)
+        throw new Error("invalid cell");
+    const [, hex, file] = m;
+    if (hex) {
+        if ((hex.length - 2) % 2 !== 0 || hex.length > 66)
+            throw new Error("invalid hex cell");
+        return { cell, type: "hex", hex: hex, file: undefined };
+    }
+    else {
+        if (header == "INFO") {
+            throw new Error("file not permitted for INFO cell");
+        }
+        return { cell, type: "file", hex: undefined, file };
+    }
+}
+function parsePermCsvHeader({ header, index }) {
+    let h = header.trim().toUpperCase();
+    let perm = true;
+    if (h.endsWith("!")) {
+        h = h.slice(0, -1);
+        perm = false;
+    }
+    if (h in CELL_TYPES) {
+        return { header: h, perm, index };
+    }
+    else {
+        throw new Error(`Invalid column type: ${h}`);
+    }
+}
+export function parsePermCsvCell(input, header) {
+    const cell = input.trim();
+    if (cell.length == 0)
+        return { cell, type: "empty", count: 0 };
+    // (0xHEX | FILE) [* NUMBER] with optional spaces around *
+    const re = /^(?:(0x[0-9A-Fa-f]+)|([^\s*]+))\s*(?:\*\s*(\d+))?$/;
+    const m = cell.match(re);
+    if (!m)
+        throw new Error("invalid cell");
+    const [, hex, file, num] = m;
+    if (hex) {
+        if ((hex.length - 2) % 2 !== 0 || hex.length > 66)
+            throw new Error("invalid hex cell");
+        return {
+            cell,
+            type: "hex",
+            hex: hex,
+            file: undefined,
+            count: num ? Number(num) : 1,
+        };
+    }
+    else {
+        if (header == "INFO") {
+            throw new Error("file cell not permitted for INFO column");
+        }
+        return {
+            cell,
+            type: "file",
+            hex: undefined,
+            file,
+            count: num ? Number(num) : 1,
+        };
+    }
+}
+export function resolveCellPath(csvFile) {
+    return function (cellFile) {
+        if (path.isAbsolute(cellFile))
+            return cellFile;
+        const dir = path.dirname(csvFile);
+        if (path.isAbsolute(csvFile)) {
+            return path.resolve(dir, cellFile);
+        }
+        else {
+            return path.normalize(path.join(dir, cellFile));
+        }
+    };
+}
+function HashCellFileMemo(csvFile, deps) {
+    const resolvePath = resolveCellPath(csvFile);
+    function hashCellFile(p) {
+        const input = computeHashFromFile(resolvePath(p));
+        if (!deps.has(input.path)) {
+            deps.set(input.path, input);
+        }
+        return input;
+    }
+    return memoize(hashCellFile);
+}

package/dist/utils.js

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+import * as JSON11 from "json11";
 import { isHex, hexToU8a } from "@polkadot/util";
 import { base64Decode } from "@polkadot/util-crypto/base64";
 import { decodePair } from "@polkadot/keyring/pair/decode";
@@ -190,3 +191,12 @@ export function toRelationId(v) {
     }
     return n;
 }
+export function stringify(v, options) {
+    return JSON11.stringify(v, options ?? { quoteNames: true, quote: '"', withBigInt: false });
+}
+export function j11String(v, options) {
+    return JSON11.stringify(v, options);
+}
+export function j11Parse(str) {
+    return JSON11.parse(str);
+}

package/package.json

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