@everyprotocol/every-cli 0.1.3 → 0.1.4

package/.every.toml

@@ -2,7 +2,7 @@
 id = 31337
 rpc = "http://127.0.0.1:8545"
 explorer = "http://127.0.0.1:8545"
-observer = "localnet"
+observer = "dev"
 
 [universes.anvil.contracts]
 SetRegistry = "0x854C35Fd2b65fE9fcE71dddE91De8c3e1A7Dc8Ae"
@@ -11,7 +11,7 @@ KindRegistry = "0x7A8B3E5A9c227858C5917b7de8ba1684Cd868630"
 ElementRegistry = "0x8De1EE1dbAE2Ffd1CAe1e6bA83E6cAede1461507"
 ObjectMinter = "0x12CaBC370b316F247126F3Fab529Ee25e03aE226"
 
-[observers.localnet]
+[observers.dev]
 rpc = "ws://localhost:9944"
-gateway = "http://every.im.local"
+gateway = "http://localhost:3456"
 explorer = "http://every.im.local"

package/dist/abi.js

@@ -11,6 +11,7 @@ export const abi = {
         omniRegistry: loadNonFuncAbiItems("OmniRegistry"),
         kindRegistry: loadNonFuncAbiItems("KindRegistry"),
         setRegistry: loadNonFuncAbiItems("SetRegistry"),
+        setContract: loadNonFuncAbiItems("ISet"),
     },
     funcs: {
         kindRegistry: loadFuncAbiItems("IKindRegistry"),

package/dist/cmdgen.js

@@ -1,144 +1,56 @@
+import { Argument, Command } from "commander";
 import { createPublicClient, http } from "viem";
-import { configureCommand } from "./cmds.js";
-import JSON5 from "json5";
-import { rstrip, excludes, includes, lstrip, startsWith, checkArguments } from "./utils.js";
-import { replaceAbiParamAt, insertAbiParamAt, abi } from "./abi.js";
-import { genMintCommand } from "./mint.js";
-import { genRelateCommand, genUnrelateCommand } from "./relate.js";
-export function generateCommands() {
-    const kind = abi.funcs.kindRegistry
-        .map(AbiToCommand({ contract: "KindRegistry", nonFuncs: abi.nonFuncs.kindRegistry, cmdName: lstrip("kind") }))
-        .sort(byPreferredOrder);
-    const set = [
-        ...abi.funcs.setRegistryAdmin.map(AbiToCommand(setRegistryAdminCmdConfig)),
-        ...abi.funcs.setRegistry
-            .filter(excludes(["setRegister", "setUpdate", "setTouch", "setUpgrade"]))
-            .map(AbiToCommand({ contract: "SetRegistry", nonFuncs: abi.nonFuncs.setRegistry, cmdName: lstrip("set") })),
-    ].sort(byPreferredOrder);
-    const relation = abi.funcs.omniRegistry
-        .filter(startsWith("relation"))
-        .map(AbiToCommand({
-        contract: "OmniRegistry",
-        nonFuncs: abi.nonFuncs.omniRegistry,
-        cmdName: lstrip("relation"),
-    }))
-        .sort(byPreferredOrder);
-    const unique = abi.funcs.elemRegistry
-        .filter(startsWith("unique"))
-        .map(AbiToCommand({ contract: "ElementRegistry", nonFuncs: abi.nonFuncs.elemRegistry, cmdName: lstrip("unique") }))
-        .sort(byPreferredOrder);
-    const value = abi.funcs.elemRegistry
-        .filter(startsWith("value"))
-        .map(AbiToCommand({ contract: "ElementRegistry", nonFuncs: abi.nonFuncs.elemRegistry, cmdName: lstrip("value") }))
-        .sort(byPreferredOrder);
-    const object = [
-        genMintCommand(),
-        genRelateCommand(),
-        genUnrelateCommand(),
-        // write functions
-        ...abi.funcs.setContract
-            .filter(includes("update,upgrade,touch,transfer".split(",")))
-            .map(AbiToCommand(setContractObjectCmdConfig)),
-        // read functions
-        ...abi.funcs.setContract
-            .filter(excludes("update,upgrade,touch,transfer,uri,supportsInterface".split(",")))
-            .map(AbiToCommand(setContractObjectCmdConfig)),
-        ...abi.funcs.setContract
-            .filter(includes("uri".split(",")))
-            .map(AbiToCommand({ ...setContractObjectCmdConfig, txnPrepare: objectUriTxnPrepare })),
-    ].sort(byPreferredOrder);
-    const mintpolicy = [
-        ...abi.funcs.objectMinterAdmin.map(AbiToCommand(objectMinterAdminCmdConfig)),
-        ...abi.funcs.objectMinter
-            .filter(startsWith("mintPolicy"))
-            .filter(excludes("mintPolicyAdd,mintPolicyEnable,mintPolicyDisable".split(",")))
-            .map(AbiToCommand({ contract: "ObjectMinter", nonFuncs: abi.nonFuncs.objectMinter, cmdName: lstrip("mintPolicy") })),
-    ].sort(byPreferredOrder);
-    return { kind, set, relation, unique, value, mintpolicy, object };
-}
-const setContractObjectCmdConfig = {
-    contract: "ISet",
-    nonFuncs: [],
-    cmdAbi: function (txnAbi) {
-        return replaceAbiParamAt(txnAbi, 0, {
-            name: "sid",
-            type: "string",
-            doc: "Scoped Object ID (in form of set.id, e.g., 17.1)",
-        });
-    },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    txnPrepare: async function (ctx) {
-        const rawArgs = checkArguments(ctx.cmd.args, ctx.cmdAbi);
-        const [set, id] = rawArgs[0].split(".");
-        const args = [JSON5.parse(id), ...rawArgs.slice(1)];
-        const publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
-        const address = (await publicClient.readContract({
-            address: ctx.conf.contracts["SetRegistry"],
-            abi: abi.setContract,
-            functionName: "setContract",
-            args: [set],
-        }));
-        return { address: address, tag: ctx.contract, args };
-    },
-};
-const objectUriTxnPrepare = async function (ctx) {
-    const rawArgs = checkArguments(ctx.cmd.args, ctx.cmdAbi);
-    // const [set, id] = rawArgs[0].split(".");
-    const set = rawArgs[0].split(".")[0];
-    const publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
-    const address = (await publicClient.readContract({
-        address: ctx.conf.contracts["SetRegistry"],
-        abi: abi.setContract,
-        functionName: "setContract",
-        args: [set],
-    }));
-    return { address: address, tag: ctx.contract, args: [] };
+import { submitSimulation } from "./ethereum.js";
+import { Logger } from "./logger.js";
+import { outputOptions, universe, writeOptions } from "./commander-patch.js";
+import { FromOpts } from "./from-opts.js";
+import { coerceValue } from "./utils.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getReadAction = (config, funName, abiFunc, abi) => async function readAction() {
+    const opts = this.opts();
+    const conf = FromOpts.getUniverseConfig(opts);
+    const address = await config.getContract(conf, this.args, abiFunc);
+    const args = (config.getFuncArgs ?? CommandGenDefaults.getFuncArgs)(this.args, abiFunc);
+    const console = new Logger(opts);
+    const publicClient = createPublicClient({ transport: http(conf.rpc) });
+    const result = await publicClient.readContract({ address, abi, functionName: funName, args });
+    console.log(result);
+    console.result(result);
 };
-const setRegistryAdminCmdConfig = {
-    contract: "ISetRegistryAdmin",
-    nonFuncs: abi.nonFuncs.setRegistry,
-    cmdName: rstrip("Set"),
-    cmdAbi: function (txnAbi) {
-        return insertAbiParamAt(txnAbi, 0, {
-            name: "contract",
-            type: "address",
-            doc: "address of the set contract",
-        });
-    },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    txnPrepare: async function (ctx) {
-        const raw = checkArguments(ctx.cmd.args, ctx.cmdAbi);
-        const address = raw[0];
-        const args = raw.slice(1);
-        return { address, tag: ctx.contract, args };
-    },
+// 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 { 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 };
+    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
 };
-const objectMinterAdminCmdConfig = {
-    contract: "IObjectMinterAdmin",
-    nonFuncs: abi.nonFuncs.objectMinter,
-    cmdName: rstrip("MintPolicy"),
-    cmdAbi: function (txnAbi) {
-        return insertAbiParamAt(txnAbi, 0, {
-            name: "contract",
-            type: "address",
-            doc: "address of the contract",
-        });
-    },
-    txnPrepare: async function (ctx) {
-        const raw = checkArguments(ctx.cmd.args, ctx.cmdAbi);
-        const address = raw[0];
-        const args = raw.slice(1);
-        return { address, tag: ctx.contract, args };
-    },
+export const getCommandGen = (config) => function genCmd(cmdName) {
+    const { getFuncName, getAbiFuncs, getAbiNonFuncs } = config;
+    const funcName = getFuncName(cmdName);
+    const abiFuncs = getAbiFuncs(funcName);
+    const abiNonFuncs = getAbiNonFuncs(funcName);
+    // console.log(funcName, abiFuncs);
+    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 args = (config.getCmdArgs ?? CommandGenDefaults.getCmdArgs)(abiFuncDoc);
+    const abiContract = [...abiFuncs, ...abiNonFuncs];
+    const action = isRead
+        ? getReadAction(config, funcName, abiFuncDoc, abiContract)
+        : getWriteAction(config, funcName, abiFuncDoc, abiContract);
+    return new Command(cmdName).description(description).addOptions(options).addArguments(args).action(action);
 };
-function AbiToCommand(conf) {
-    return (txnAbi) => configureCommand(txnAbi, conf);
-}
-function byPreferredOrder(a, b) {
-    const ORDER_MAP = new Map("mint,register,update,upgrade,touch,transfer,relate,unrelate,owner,descriptor,elements,revision,sota,snapshot,status,admint,contract,rule,uri"
-        .split(",")
-        .map((name, index) => [name, index]));
-    const aIndex = ORDER_MAP.get(a.name()) ?? Infinity;
-    const bIndex = ORDER_MAP.get(b.name()) ?? Infinity;
-    return aIndex - bIndex;
+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])),
+    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/balance.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import "@polkadot/api-augment/substrate";
+import * as JSON11 from "json11";
+import columify from "columnify";
+import { u8aFixLength } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { submitSubTxUI } from "../substrate.js";
+import { network } from "../commander-patch.js";
+import { Logger } from "../logger.js";
+const balanceQueryCmd = new Command("query")
+    .description("Query account balance")
+    .argument("<address>", "Account address (SS58 or 0x hex)")
+    .addOption(network)
+    .addOutputOptions()
+    .subReadAction(async function (api, address) {
+    const accountId = u8aFixLength(decodeAddress(address), 256);
+    const accountInfo = (await api.query.system.account(accountId));
+    const symbol = api.registry.chainTokens[0];
+    const free = accountInfo.data.free.toBigInt();
+    const reserved = accountInfo.data.reserved.toBigInt();
+    const frozen = accountInfo.data.frozen.toBigInt();
+    const balance = { free, reserved, frozen };
+    const result = { address, symbol, balance };
+    const console = new Logger(this.opts());
+    console.log(columify([[symbol, JSON11.stringify(balance)]], { showHeaders: false }));
+    console.result(result);
+});
+const balanceTransferCmd = new Command("transfer")
+    .description("Transfer balance to account")
+    .argument("<address>", "Recipient account address (SS58 or 0x hex)")
+    .argument("<amount>", "Amount in base units")
+    .addOption(network)
+    .addKeystoreOptions()
+    .addOutputOptions()
+    .subWriteAction(async function (api, pair, address, amount) {
+    const tx = api.tx.balances.transferKeepAlive(address, amount);
+    const console = new Logger(this.opts());
+    await submitSubTxUI(api, tx, pair, console);
+});
+export const balanceCmd = new Command("balance")
+    .description("manage balances")
+    .addCommand(balanceQueryCmd)
+    .addCommand(balanceTransferCmd);

package/dist/cmds/config.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import { _loadMergedConfig } from "../config.js";
+const configShowCmd = new Command("show")
+    .description("show mreged configuration")
+    .option("-u, --universe <universe>", "Show config of this universe only")
+    .option("-n, --network <network>", "Show config of this network only")
+    .action(async (opts) => {
+    const [config] = _loadMergedConfig();
+    const universe = opts.universe
+        ? (config.universes?.[opts.universe] ??
+            (() => {
+                throw new Error(`config for universe ${opts.universe} not found`);
+            })())
+        : undefined;
+    const network = opts.network
+        ? (config.observers?.[opts.network] ??
+            (() => {
+                throw new Error(`config for network ${opts.network} not found`);
+            })())
+        : undefined;
+    let result;
+    if (universe && !network) {
+        result = universe;
+    }
+    else if (network && !universe) {
+        result = network;
+    }
+    else if (universe && network) {
+        result = {
+            [opts.universe]: universe,
+            [opts.network]: network,
+        };
+    }
+    else {
+        result = config;
+    }
+    console.log(JSON.stringify(result, null, 2));
+});
+const configFilesCmd = new Command("files").description("list configuration files searched").action(async () => {
+    const [, files] = _loadMergedConfig();
+    files.forEach((f) => console.log(f));
+});
+export const configCmd = new Command("config")
+    .description("view merged configuration and source files")
+    .addCommand(configShowCmd)
+    .addCommand(configFilesCmd);

package/dist/cmds/kind.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    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));

package/dist/cmds/matter.js

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import "@polkadot/api-augment/substrate";
+import * as fs from "fs";
+import * as JSON11 from "json11";
+import columify from "columnify";
+import { computeMatterHash, guessContentType, loadBinary } from "../utils.js";
+import { submitTransaction } from "../substrate.js";
+import { network } from "../commander-patch.js";
+import { Logger } from "../logger.js";
+const matterRegisterCmd = new Command("register")
+    .description("Register matter on the Substrate chain")
+    .argument("<files...>", "Paths of matter blob files")
+    .option("--mime <string>", "Matter mime")
+    .option("--form <number>", "Matter form", "1")
+    .addOption(network)
+    .addKeystoreOptions()
+    .addOutputOptions()
+    .subWriteAction(async function (api, pair, files) {
+    const opts = this.opts();
+    const console = new Logger(opts);
+    const materials = [];
+    for (const file of files) {
+        const [filePath, form_, mime_] = file.split(":");
+        const form = Number(form_ ?? opts.form ?? "1");
+        const mime = mime_ || opts.mime || guessContentType(filePath);
+        materials.push({ filePath, form, mime });
+    }
+    const txns = [];
+    for (const { filePath, form, mime } of materials) {
+        const content = 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}`);
+        const events = r.events.map((e) => [e.event.method, JSON11.stringify(e.event.data.toJSON())]);
+        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 matterHashCmd = new Command("hash")
+    .description("Register matter on the Substrate chain")
+    .argument("<files...>", "Paths of matter blob files")
+    .option("--mime <string>", "Matter mime")
+    .option("--form <number>", "Matter form", "1")
+    .addOutputOptions()
+    .action(async function (files) {
+    const opts = this.opts();
+    const console = new Logger(opts);
+    const matters = [];
+    for (const file of files) {
+        const [path, form_, mime_] = file.split(":");
+        const form = Number(form_ ?? opts.form ?? "1");
+        const mime = mime_ || opts.mime || guessContentType(path);
+        const blob = loadBinary(path);
+        const hash = computeMatterHash(form, mime, blob);
+        matters.push({ hash, form, mime, blob: blob.length, path });
+    }
+    console.log(columify(matters));
+    console.result(matters);
+});
+export const matterCmd = new Command("matter")
+    .description("matter utilities")
+    .addCommand(matterRegisterCmd)
+    .addCommand(matterHashCmd);

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 } 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");
+        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));