@everyprotocol/every-cli 0.1.15 → 0.1.17

package/dist/abi.js

@@ -27,15 +27,15 @@ export const abi = {
         ...parseAbi(["function setContract(uint64 id) external view returns (address code)"]),
         ...loadNonFuncAbiItems("SetRegistry"),
     ],
-    mint: [
+    minterMint: [
         ...parseAbi([
             "function mint(address to, address set, uint64 id, bytes memory data, bytes memory auth, uint32 policy) payable",
         ]),
         ...loadNonFuncAbiItems("ObjectMinter"),
         ...loadNonFuncAbiItems("ISet"),
     ],
-    create: [
-        ...parseAbi(["function create(address to, uint64 id0, bytes calldata data) payable"]),
+    setMint: [
+        ...parseAbi(["function mint(address to, uint64 id0, bytes calldata data) payable"]),
         ...loadNonFuncAbiItems("ISet"),
     ],
     relation: [

package/dist/abi2.js

@@ -0,0 +1,52 @@
+import { toFunctionSignature } from "viem";
+import fs from "fs";
+import path from "path";
+import { memoize } from "lodash-es";
+import { __dirname } from "./utils.js";
+function getSelectorsInner() {
+    return loadAbiFromFile("events-errors");
+}
+// export const getSelectors = memoize(getSelectorsInner);
+export const getNonFuncs = memoize(getSelectorsInner);
+function getFuncsInner(name) {
+    return loadFuncAbiItems(name);
+}
+export const getFuncs = memoize(getFuncsInner);
+function getAbiInner(name) {
+    return [...getFuncs(name), ...getNonFuncs()];
+}
+export const getAbi = memoize(getAbiInner);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function loadAbiFromFile(name) {
+    const file = path.resolve(__dirname, "../abis2", `${name}.json`);
+    const content = fs.readFileSync(file, "utf8");
+    return JSON.parse(content);
+}
+export function loadNonFuncAbiItems(name) {
+    const abi = loadAbiFromFile(name);
+    return (abi.abi || []).filter((item) => item.type === "event" || item.type === "error");
+}
+export function loadFuncAbiItems(name) {
+    const abi = loadAbiFromFile(name);
+    const metadata = abi.metadata?.output || {};
+    const userMethods = metadata.userdoc?.methods || {};
+    const devMethods = metadata.devdoc?.methods || {};
+    return (abi.abi
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .filter((item) => item.type === "function")
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .map((item) => {
+        const signature = toFunctionSignature(item);
+        const userdoc = userMethods[signature] || {};
+        const devdoc = devMethods[signature] || {};
+        const _metadata = {
+            signature,
+            ...devdoc,
+            ...userdoc,
+        };
+        return {
+            ...item,
+            _metadata,
+        };
+    }));
+}

package/dist/abicmd.js

@@ -0,0 +1,121 @@
+import { Argument, Command, Option } from "commander";
+import { getNonFuncs } from "./abi2.js";
+import { coerceValue } from "./utils.js";
+import { outputOptions, universe, writeOptions } from "./commander-patch.js";
+import { submitSimulation } from "./ethereum.js";
+import { Logger } from "./logger.js";
+import { FromOpts } from "./from-opts.js";
+export function genAbiCommand(cmdName, abiFunc, cmdConf) {
+    const { cmdArgs, cmdOpts, argGetters } = genAbiCommandParams(abiFunc, cmdConf.params);
+    const desc = cmdConf.descs?.[`${abiFunc.name}`] ?? abiFunc._metadata.notice ?? "";
+    return new Command(cmdName)
+        .description(desc)
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(AbiCommandAction(abiFunc, argGetters, cmdConf.prepare));
+}
+function ArgGetterArg(i) {
+    return function (cmd) {
+        return cmd.processedArgs[i];
+    };
+}
+function ArgGetterOpt(name) {
+    return function (cmd) {
+        return cmd.getOptionValue(name);
+    };
+}
+export function ArgParser(input) {
+    // eslint-disable-next-line
+    return function (value, previous) {
+        return coerceValue(value, input);
+    };
+}
+function genAbiCommandParams(abiFunc, params) {
+    const cmdArgs = [];
+    const cmdOpts = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const argGetters = [];
+    {
+        const pfn = params?.[`${abiFunc.name}.PREPEND`] ?? params?.[`.PREPEND`];
+        if (pfn) {
+            const argOrOpt = pfn();
+            if (argOrOpt instanceof Option) {
+                cmdOpts.push(argOrOpt);
+                argGetters.push(ArgGetterOpt(argOrOpt.name()));
+            }
+            else {
+                const newLen = cmdArgs.push(argOrOpt);
+                argGetters.push(ArgGetterArg(newLen - 1));
+            }
+        }
+    }
+    abiFunc.inputs.map((input) => {
+        const name = input.name;
+        const pfn = params?.[`${abiFunc.name}.${name}`] ?? params?.[`.${name}`] ?? (() => new Argument(`<${name}>`));
+        const argOrOpt = pfn();
+        if (!hasDescription(argOrOpt)) {
+            const desc = abiFunc._metadata?.params?.[name] || `parameter ${name}: ${input.type}`;
+            argOrOpt.description = desc;
+        }
+        if (!hasArgParser(argOrOpt)) {
+            argOrOpt.argParser(ArgParser(input));
+        }
+        if (argOrOpt instanceof Option) {
+            cmdOpts.push(argOrOpt);
+            argGetters.push(ArgGetterOpt(argOrOpt.name()));
+        }
+        else {
+            const newLen = cmdArgs.push(argOrOpt);
+            argGetters.push(ArgGetterArg(newLen - 1));
+        }
+    });
+    if (abiFunc.stateMutability == "view" || abiFunc.stateMutability == "pure") {
+        cmdOpts.push(universe, ...outputOptions);
+    }
+    else {
+        cmdOpts.push(...writeOptions, ...outputOptions);
+    }
+    return { cmdArgs, cmdOpts, argGetters };
+}
+function AbiCommandReadAction(abiFunc, argGetters, // eslint-disable-line @typescript-eslint/no-explicit-any
+contractGetter) {
+    return async function action() {
+        const opts = this.opts();
+        const console = new Logger(opts);
+        const { conf, publicClient } = FromOpts.toReadEthereum(opts);
+        const args0 = argGetters.map((getArg) => getArg(this));
+        const [address, args, altAbiFunc] = await contractGetter(conf, publicClient, args0, abiFunc.name);
+        const abiFuncFinal = altAbiFunc ?? abiFunc;
+        const abi = [abiFuncFinal, ...getNonFuncs()];
+        const result = await publicClient.readContract({ address, abi, functionName: abiFuncFinal.name, args });
+        console.log(result);
+        console.result(result);
+    };
+}
+function AbiCommandWriteAction(abiFunc, argGetters, prepare) {
+    return async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const args0 = argGetters.map((getArg) => getArg(this));
+        const [address, args, altAbiFunc] = await prepare(conf, publicClient, args0, abiFunc.name);
+        const account = walletClient.account;
+        const abiFuncFinal = altAbiFunc ?? abiFunc;
+        const abi = [abiFuncFinal, ...getNonFuncs()];
+        const sim = { address, abi, functionName: abiFuncFinal.name, args, account };
+        await submitSimulation(sim, publicClient, walletClient, new Logger(opts));
+    };
+}
+function AbiCommandAction(abiFunc, argGetters, prepare) {
+    return abiFunc.stateMutability == "view" || abiFunc.stateMutability == "pure"
+        ? AbiCommandReadAction(abiFunc, argGetters, prepare)
+        : AbiCommandWriteAction(abiFunc, argGetters, prepare);
+}
+function hasArgParser(obj) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const anyObj = obj;
+    return typeof anyObj._fn === "function" || typeof anyObj._argParser === "function";
+}
+function hasDescription(argOrOpt) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return typeof argOrOpt.description === "string" && argOrOpt.description.trim().length > 0;
+}

package/dist/artifact.js

@@ -45,7 +45,7 @@ export function getCreationCode(artifact) {
 }
 /** Get ABI array from a Foundry/solc artifact JSON object. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getAbi(artifact) {
+export function getAbiFromArtifact(artifact) {
     const abi = artifact?.abi;
     if (!Array.isArray(abi))
         throw new Error("abi missing or not an array");

package/dist/cmds/kind.js

@@ -1,23 +1,34 @@
 import { Argument, Command, Option } from "commander";
-import { abi } from "../abi.js";
-import { getCommandGen, makeFuncName } from "../cmdgen.js";
+import { getAbi, getFuncs } from "../abi2.js";
 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,
-});
+import { genAbiCommand } from "../abicmd.js";
+import { makeFuncName } from "../cmdgen.js";
 const registerCmd = genRegisterCmd();
 const updateCmd = genUpdateCmd();
-const otherCmds = "upgrade,touch,transfer,owner,descriptor,snapshot".split(",").map(genKindCmd);
+const cmdConfig = {
+    params: {
+        ".rev0": () => new Option(`--rev <rev0>`).default(0),
+        ".kindRev": () => new Option(`--krev <rev0>`).default(0),
+        ".setRev": () => new Option(`--srev <rev0>`).default(0),
+    },
+    // eslint-disable-next-line
+    prepare: (conf, client, args) => [
+        conf.contracts.KindRegistry,
+        args,
+        undefined,
+    ],
+};
+const abiFuncs = getFuncs("IKindRegistry");
+const otherCmds = "upgrade,touch,transfer,owner,descriptor,snapshot".split(",").map((name) => {
+    const funcName = makeFuncName(name, "kind");
+    const abiFunc = abiFuncs.filter((i) => i.name == funcName)[0];
+    return genAbiCommand(name, abiFunc, cmdConfig);
+});
 export const kindCmd = new Command("kind")
     .description("manage kinds")
     .addCommand(registerCmd)
@@ -25,8 +36,7 @@ export const kindCmd = new Command("kind")
     .addCommands(otherCmds);
 function genRegisterCmd() {
     const funcName = "kindRegister";
-    const abiFuncs = abi.funcs.kindRegistry.filter((i) => i.name == funcName);
-    const abiNonFuncs = abi.nonFuncs.kindRegistry;
+    const abiFuncs = getFuncs("IKindRegistry").filter((i) => i.name == funcName);
     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");
@@ -56,7 +66,7 @@ function genRegisterCmd() {
         const account = walletClient.account;
         const simulation = {
             address,
-            abi: [...abiFuncs, ...abiNonFuncs],
+            abi: getAbi("IKindRegistry"),
             functionName: funcName,
             args,
             account,
@@ -70,9 +80,9 @@ function genRegisterCmd() {
         .action(getCmdAction);
 }
 function genUpdateCmd() {
-    const funcName = "kindUpdate";
-    const abiFuncs = abi.funcs.kindRegistry.filter((i) => i.name == funcName);
-    const abiNonFuncs = abi.nonFuncs.kindRegistry;
+    // const funcName = "kindUpdate";
+    // const abiFuncs = (abi.funcs.kindRegistry as AbiFunctionDoc[]).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");
@@ -83,22 +93,22 @@ function genUpdateCmd() {
         const opts = cmd.opts();
         const args = [cmd.args[0]];
         const ZERO32 = toHex(0, { size: 32 });
-        let sig;
+        // let sig;
         if (opts.relations) {
             if (opts.code || opts.data) {
-                sig = "kindUpdate(uint64,bytes32,bytes32,uint64[])";
+                // 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[])";
+                // sig = "kindUpdate(uint64,uint64[])";
                 args.push(typeof opts.relations == "boolean" ? [] : opts.relations);
             }
         }
         else {
             if (opts.code || opts.data) {
-                sig = "kindUpdate(uint64,bytes32,bytes32)";
+                // sig = "kindUpdate(uint64,bytes32,bytes32)";
                 args.push(opts.code ?? ZERO32);
                 args.push(opts.data ?? ZERO32);
             }
@@ -106,18 +116,17 @@ function genUpdateCmd() {
                 throw new Error("");
             }
         }
-        const abiFunc = abiFuncs.filter((f) => f._metadata.signature == sig)[0];
-        return [args, abiFunc];
+        return args;
     }
     async function getCmdAction() {
         const opts = this.opts();
-        const [args, abiFunc] = getFuncArgs(this);
+        const args = getFuncArgs(this);
         const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
         const address = conf.contracts.KindRegistry;
         const account = walletClient.account;
         const simulation = {
             address,
-            abi: [abiFunc, ...abiNonFuncs],
+            abi: getAbi("IKindRegistry"),
             functionName: "kindUpdate",
             args,
             account,