npm - @everyprotocol/every-cli - Versions diffs - 0.1.7 → 0.1.9 - Mend

@everyprotocol/every-cli 0.1.7 → 0.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/cmdgen.js CHANGED Viewed

@@ -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,11 +20,12 @@ 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;
     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) {
@@ -36,7 +37,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 +50,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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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,298 +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}`);
-        }
-    };
-    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/relation.js CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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";
@@ -167,3 +168,35 @@ 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;
+}
+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 CHANGED Viewed

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