@everyprotocol/every-cli 0.1.3 → 0.1.5

package/dist/cmds/matter.js

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

package/dist/cmds/minter.js

@@ -0,0 +1,31 @@
+import { Argument, Command } from "commander";
+import { abi } from "../abi.js";
+import { CommandGenDefaults, getCommandGen, makeFuncName } from "../cmdgen.js";
+const adminCmdConfig = {
+    getFuncName: (cmdName) => `${cmdName}MintPolicy`,
+    getAbiFuncs: (funcName) => abi.funcs.objectMinterAdmin.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.objectMinter,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => args[0],
+    // eslint-disable-next-line
+    getFuncArgs: (args, abiFunc) => args.slice(1),
+    getCmdArgs: (abiFunc) => [
+        new Argument(`<contract>`, "address of the set contract"),
+        ...CommandGenDefaults.getCmdArgs(abiFunc),
+    ],
+};
+const userCmdConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `mintPolicy`),
+    getAbiFuncs: (funcName) => abi.funcs.objectMinter.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.objectMinter,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.ObjectMinter,
+};
+const adminCmds = "add,enable,disable".split(",");
+const userCmds = "count,get,search".split(",");
+export const minterCmd = new Command("minter")
+    .description("manage mint policies")
+    .addCommands(adminCmds.map(getCommandGen(adminCmdConfig)))
+    .addCommands(userCmds.map(getCommandGen(userCmdConfig)));

package/dist/cmds/object.js

@@ -0,0 +1,175 @@
+import { Argument, Command } from "commander";
+import { createPublicClient, http, parseUnits } from "viem";
+import { parseAbiItem, erc1155Abi, erc721Abi } from "viem";
+import { abi } from "../abi.js";
+import { submitSimulation } from "../ethereum.js";
+import { Logger } from "../logger.js";
+import { parseBigInt, parseNode3, parseNode4, parseSID } from "../parsers.js";
+import { CommandGenDefaults, getCommandGen } from "../cmdgen.js";
+import { FromOpts } from "../from-opts.js";
+import { coerceValue } from "../utils.js";
+const objectRelateCmd = new Command()
+    .name("relate")
+    .description("Link a tail object to a head object through a relation")
+    .addWriteOptions()
+    .argument("<tail>", "tail node, in form of [[data.]grant.]set.id", parseNode4)
+    .argument("<rel>", "relation ID", parseBigInt)
+    .argument("<head>", "head node in form of [grant.]set.id, ", parseNode3)
+    .action(async function () {
+    await relateAction(this, "relate");
+});
+const objectUnrelateCmd = new Command()
+    .name("unrelate")
+    .description("Unlinks a tail object from a head object")
+    .addWriteOptions()
+    .argument("<tail>", "tail node, in form of [[data.]grant.]set.id", parseNode4)
+    .argument("<rel>", "relation ID", parseBigInt)
+    .argument("<head>", "head node in form of [grant.]set.id, ", parseNode3)
+    .action(async function () {
+    await relateAction(this, "unrelate");
+});
+const objectMintCmd = new Command()
+    .name("mint")
+    .description("Mint an object via the object minter or directly from the set")
+    .option("--to <address>", "specify the recipient")
+    .option("--value <amount>", "the amount of ETH to send together", "0")
+    .option("--auth <data>", "authorization data for a permissioned mint", "0x")
+    .option("--policy <index>", "the index number of the mint policy", "0")
+    .option("--no-minter", "mint directly from set contract instead of using ObjectMinter")
+    .addWriteOptions()
+    .argument("<sid>", "scoped object ID, in form of set.id (e.g., 17.1)")
+    .argument("[data]", "additional input data", "0x")
+    .action(mintAction);
+const objectSendCmd = new Command("send")
+    .description("Call a function by signature (dry-run: prints calldata)")
+    .option("--sig <sig>", "Function signature, e.g. 'transfer(address,uint256)'")
+    .argument("<args...>", "Function arguments (arrays/tuples as JSON)")
+    .addWriteOptions()
+    .action(sendAction);
+const cmdGenConfig = {
+    getFuncName: (cmdName) => cmdName,
+    getAbiFuncs: (funcName) => abi.funcs.setContract.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => [...abi.nonFuncs.setContract],
+    // eslint-disable-next-line
+    getContract: async function (conf, args, abiFunc) {
+        const publicClient = createPublicClient({ transport: http(conf.rpc) });
+        const address = await publicClient.readContract({
+            address: conf.contracts.SetRegistry,
+            abi: abi.setContract,
+            functionName: "setContract",
+            args: [args[0].set],
+        });
+        return address;
+    },
+    // eslint-disable-next-line
+    getFuncArgs: function (args, abiFunc) {
+        return abiFunc.name == "uri" ? args.slice(1) : [args[0].id, ...args.slice(1)];
+    },
+    getCmdArgs: function (abiFunc) {
+        const sid = new Argument(`<sid>`, "sid of the object").argParser(parseSID);
+        const args0 = CommandGenDefaults.getCmdArgs(abiFunc);
+        return abiFunc.name == "uri" ? [sid] : [sid, ...args0.slice(1)];
+    },
+};
+const cmdGen = getCommandGen(cmdGenConfig);
+const writeCmds = "upgrade,touch,transfer".split(",");
+const readCmds = "owner,descriptor,snapshot,uri".split(",");
+export const objectCmd = new Command("object")
+    .description("manage objects")
+    .addCommands(writeCmds.map(cmdGen))
+    .addCommand(objectMintCmd)
+    .addCommand(objectRelateCmd)
+    .addCommand(objectUnrelateCmd)
+    .addCommand(objectSendCmd)
+    .addCommands(readCmds.map(cmdGen));
+async function mintAction() {
+    const opts = this.opts();
+    const args0 = this.args;
+    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+    const setRegistry = conf.contracts["SetRegistry"];
+    const account = walletClient.account;
+    const [set, id] = args0[0].split(".");
+    const setContract = (await publicClient.readContract({
+        address: setRegistry,
+        abi: abi.setContract,
+        functionName: "setContract",
+        args: [BigInt(set)],
+    }));
+    const value = parseUnits(opts.value || "0", 18);
+    const recipientAddress = (opts.to || account.address);
+    const mintData = (args0[1] || "0x");
+    const simulation = opts.minter
+        ? {
+            address: conf.contracts["ObjectMinter"],
+            abi: abi.mint,
+            functionName: "mint",
+            args: [recipientAddress, setContract, BigInt(id), mintData, opts.auth || "0x", Number(opts.policy || "0")],
+            account,
+            value,
+        }
+        : {
+            address: setContract,
+            abi: abi.create,
+            functionName: "create",
+            args: [recipientAddress, BigInt(id), mintData],
+            account,
+            value,
+        };
+    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+}
+async function relateAction(cmd, functionName) {
+    const opts = cmd.opts();
+    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+    const address = conf.contracts["OmniRegistry"];
+    const simulation = {
+        address,
+        abi: abi.relation,
+        functionName,
+        args: cmd.args,
+        account: walletClient.account,
+    };
+    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+}
+async function sendAction() {
+    const opts = this.opts();
+    const args0 = this.args;
+    const { sig } = this.opts();
+    if (!sig) {
+        console.error("Error: --sig is required (e.g. --sig 'transfer(address,uint256)')");
+        this.exitOverride();
+        return;
+    }
+    const item = parseAbiItem(`function ${sig}`);
+    if (item.type !== "function")
+        throw new Error(`Not a function signature: ${sig}`);
+    const abiFunc = item;
+    const params = abiFunc.inputs ?? [];
+    if (args0.length !== params.length)
+        throw new Error(`Argument count mismatch: expected ${params.length}, got ${args0.length}`);
+    const sidIndex = params.findIndex((p) => p.type == "uint64");
+    if (sidIndex == -1)
+        throw new Error("SID type(uint64) not found in signature");
+    const [setId, objectId] = args0[sidIndex].split(".");
+    args0[sidIndex] = objectId;
+    const args = args0.map((a, i) => coerceValue(a, params[i]));
+    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+    const setRegistry = conf.contracts["SetRegistry"];
+    const account = walletClient.account;
+    const setContract = (await publicClient.readContract({
+        address: setRegistry,
+        abi: abi.funcs.setRegistry,
+        functionName: "setContract",
+        args: [BigInt(setId)],
+    }));
+    const value = parseUnits(opts.value ?? "0", 18);
+    const simulation = {
+        address: setContract,
+        abi: [abiFunc, ...abi.nonFuncs.setContract, ...erc1155Abi, ...erc721Abi],
+        functionName: abiFunc.name,
+        args: args,
+        account,
+        value,
+    };
+    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+}

package/dist/cmds/relation.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `relation`),
+    getAbiFuncs: (funcName) => abi.funcs.omniRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.omniRegistry,
+    // eslint-disable-next-line
+    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));

package/dist/cmds/set.js

@@ -0,0 +1,31 @@
+import { Argument, Command } from "commander";
+import { abi } from "../abi.js";
+import { CommandGenDefaults, getCommandGen, makeFuncName } from "../cmdgen.js";
+const adminCmdConfig = {
+    getFuncName: (cmdName) => `${cmdName}Set`,
+    getAbiFuncs: (funcName) => abi.funcs.setRegistryAdmin.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.setRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => args[0],
+    // eslint-disable-next-line
+    getFuncArgs: (args, abiFunc) => args.slice(1),
+    getCmdArgs: (abiFunc) => [
+        new Argument(`<contract>`, "address of the set contract"),
+        ...CommandGenDefaults.getCmdArgs(abiFunc),
+    ],
+};
+const userCmdConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `set`),
+    getAbiFuncs: (funcName) => abi.funcs.setRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.setRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.SetRegistry,
+};
+const userCmds = "owner,descriptor,snapshot".split(",");
+const adminCmds = "register,update,upgrade,touch".split(",");
+export const setCmd = new Command("set")
+    .description("manage sets")
+    .addCommands(adminCmds.map(getCommandGen(adminCmdConfig)))
+    .addCommands(userCmds.map(getCommandGen(userCmdConfig)));