@everyprotocol/every-cli 0.1.0

package/dist/cmdgen.js

@@ -0,0 +1,144 @@
+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.rpcUrl) });
+        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.rpcUrl) });
+    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 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 };
+    },
+};
+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 };
+    },
+};
+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;
+}

package/dist/cmds.js

@@ -0,0 +1,132 @@
+import { Argument, Command, Option } from "commander";
+import { createPublicClient, http, parseEventLogs, stringify } from "viem";
+import { getUniverseConfig } from "./config.js";
+import { checkArguments, getClients } from "./utils.js";
+export function defaultReadFunctionOptions() {
+    const options = [];
+    options.push(new Option("-u, --universe <universe>", "universe name").default("local"));
+    options.push(new Option("--dryrun", "dry run"));
+    return options;
+}
+export function defaultWriteFunctionOptions() {
+    const options = [];
+    options.push(new Option("-u, --universe <universe>", "universe name").default("local"));
+    options.push(new Option("-k, --private-key <key>", "private key to sign the transaction"));
+    options.push(new Option("-a, --account <account>", "name of the keystore to sign the transaction"));
+    options.push(new Option("-p, --password [password]", "password to decrypt the keystore"));
+    options.push(new Option("-f, --password-file <file>", "file containing the password to decrypt the keystore"));
+    options.push(new Option("--foundry", "use keystore from Foundry directory (~/.foundry/keystores)"));
+    options.push(new Option("--dryrun", "dry run"));
+    return options;
+}
+const defaultConfig = {
+    cmdAbi: (txnAbi) => txnAbi,
+    cmdName: (cmdAbi) => cmdAbi.name,
+    cmdDescription: (cmdAbi) => cmdAbi._metadata?.notice || cmdAbi.name,
+    cmdOptions: (cmdAbi) => {
+        const read = cmdAbi.stateMutability == "view" || cmdAbi.stateMutability == "pure";
+        return read ? defaultReadFunctionOptions() : defaultWriteFunctionOptions();
+    },
+    cmdArguments: (cmdAbi) => cmdAbi.inputs.map((input) => {
+        const argDesc = cmdAbi._metadata?.params?.[input.name] || `${input.type} parameter`;
+        return new Argument(`<${input.name}>`, argDesc);
+    }),
+    cmdAction: async function (ctx) {
+        const isRead = ctx.cmdAbi.stateMutability == "view" || ctx.cmdAbi.stateMutability == "pure";
+        const opts = ctx.cmd.opts();
+        const args0 = ctx.cmd.args;
+        console.log({ args0 });
+        const { address, tag, args } = await ctx.txnPrepare(ctx);
+        const abi = [ctx.txnAbi, ...ctx.nonFuncs];
+        const functionName = ctx.txnAbi.name;
+        if (isRead) {
+            const publicClient = createPublicClient({ transport: http(ctx.conf.rpcUrl) });
+            const result = await publicClient.readContract({ address, abi, functionName, args });
+            console.log(`Result:`, result);
+        }
+        else {
+            const { publicClient, walletClient } = await getClients(ctx.conf, opts);
+            const account = walletClient.account;
+            console.log({
+                isRead,
+                address: `${address} (${tag})`,
+                account: account?.address,
+                signature: ctx.txnAbi._metadata.signature,
+                args,
+            });
+            const { request } = await publicClient.simulateContract({ address, abi, functionName, args, account });
+            const hash = await walletClient.writeContract(request);
+            console.log(`Transaction sent: ${hash}`);
+            console.log("Transaction mining...");
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            console.log("Transaction mined");
+            if (receipt.logs && receipt.logs.length > 0) {
+                const parsedLogs = parseEventLogs({ abi, logs: receipt.logs });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                parsedLogs.forEach((log) => {
+                    console.log(" - Event", log.eventName, stringify(log.args));
+                });
+            }
+        }
+        console.log({ isRead, address: `${address} (${tag})`, signature: ctx.txnAbi._metadata.signature, args });
+        return;
+    },
+    txnPrepare: function (ctx) {
+        const args = checkArguments(ctx.cmd.args, ctx.cmdAbi);
+        return { address: ctx.conf.contracts[ctx.contract], tag: ctx.contract, args };
+    },
+};
+export function configureCommand(txnAbi, config) {
+    const cmdAbi = (config.cmdAbi || defaultConfig.cmdAbi)(txnAbi);
+    const name = (config.cmdName || defaultConfig.cmdName)(cmdAbi);
+    const desc = (config.cmdDescription || defaultConfig.cmdDescription)(cmdAbi);
+    const opts = (config.cmdOptions || defaultConfig.cmdOptions)(cmdAbi);
+    const args = (config.cmdArguments || defaultConfig.cmdArguments)(cmdAbi);
+    const action = async function () {
+        const ctx = {
+            conf: getUniverseConfig(this.opts()),
+            contract: config.contract,
+            cmdAbi,
+            txnAbi,
+            nonFuncs: config.nonFuncs,
+            cmd: this,
+            txnPrepare: config.txnPrepare || defaultConfig.txnPrepare,
+        };
+        await (config.cmdAction || defaultConfig.cmdAction)(ctx);
+    };
+    const cmd = new Command();
+    cmd.name(name);
+    cmd.description(desc);
+    opts.forEach((opt) => cmd.addOption(opt));
+    args.forEach((arg) => cmd.addArgument(arg));
+    cmd.action(action);
+    return cmd;
+}
+export class RenamingCommand extends Command {
+    nameCounts = new Map();
+    addCommand(cmd, opts) {
+        const originalName = cmd.name();
+        const uniqueName = this.getUniqueName(originalName);
+        if (originalName !== uniqueName) {
+            cmd.name(uniqueName);
+        }
+        return super.addCommand(cmd, opts);
+    }
+    addCommands(cmds) {
+        cmds.forEach((cmd) => this.addCommand(cmd));
+        return this;
+    }
+    resetCounts(name) {
+        if (name) {
+            this.nameCounts.delete(name);
+        }
+        else {
+            this.nameCounts.clear();
+        }
+    }
+    getUniqueName(baseName) {
+        const count = this.nameCounts.get(baseName) || 0;
+        this.nameCounts.set(baseName, count + 1);
+        return count === 0 ? baseName : `${baseName}${count + 1}`;
+    }
+}

package/dist/config.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parse as parseTOML } from "@iarna/toml";
+import { __dirname } from "./utils.js";
+// Cache
+let CONFIG_CACHED = null;
+export function getUniverseConfig(opts) {
+    const config = loadProtocolConfig();
+    const universeName = opts.universe || "local";
+    const universe = config.universes[universeName];
+    if (!universe) {
+        const available = Object.keys(config.universes).join(", ");
+        throw new Error(`Universe "${universeName}" not found. Available: ${available}`);
+    }
+    return universe;
+}
+function loadProtocolConfig() {
+    if (CONFIG_CACHED)
+        return CONFIG_CACHED;
+    const configPaths = new Set([
+        path.resolve(__dirname, "../.every.toml"),
+        path.resolve(os.homedir(), ".every.toml"),
+        path.resolve(process.cwd(), ".every.toml"),
+    ]);
+    const mergedConfig = {
+        universes: {},
+    };
+    for (const configPath of configPaths) {
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = fs.readFileSync(configPath, "utf8");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const parsed = parseTOML(raw);
+            if (parsed.universes) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                for (const [name, uni] of Object.entries(parsed.universes)) {
+                    // console.log(name, uni);
+                    mergedConfig.universes[name] = {
+                        name: name,
+                        rpcUrl: uni.rpc_url,
+                        contracts: uni.contracts || {},
+                    };
+                }
+            }
+            console.log(`Loaded configuration from ${configPath}`);
+        }
+        catch (err) {
+            console.warn(`Failed to load ${configPath}:`, err);
+        }
+    }
+    if (Object.keys(mergedConfig.universes).length === 0) {
+        console.warn("No universe configurations found");
+    }
+    CONFIG_CACHED = mergedConfig;
+    return CONFIG_CACHED;
+}

package/dist/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { generateCommands } from "./cmdgen.js";
+import { RenamingCommand } from "./cmds.js";
+import { version } from "./utils.js";
+async function main() {
+    const subCmds = generateCommands();
+    const kindCmd = new RenamingCommand().name("kind").description("manage kinds").addCommands(subCmds.kind);
+    const setCmd = new RenamingCommand().name("set").description("manage sets").addCommands(subCmds.set);
+    const relationCmd = new RenamingCommand()
+        .name("relation")
+        .description("manage relations")
+        .addCommands(subCmds.relation);
+    const uniqueCmd = new RenamingCommand().name("unique").description("manage uniques").addCommands(subCmds.unique);
+    const valueCmd = new RenamingCommand().name("value").description("manage values").addCommands(subCmds.value);
+    const objectCmd = new RenamingCommand()
+        .name("object")
+        .description("create and interact with objects")
+        .addCommands(subCmds.object);
+    const mintPolicyCmd = new RenamingCommand()
+        .name("mintpolicy")
+        .description("manage mint policies")
+        .addCommands(subCmds.mintpolicy);
+    const program = new Command()
+        .name("every")
+        .description("CLI for interacting with Every Protocol")
+        .version(version())
+        .showHelpAfterError(true);
+    program.addCommand(kindCmd);
+    program.addCommand(setCmd);
+    program.addCommand(relationCmd);
+    program.addCommand(uniqueCmd);
+    program.addCommand(valueCmd);
+    program.addCommand(objectCmd);
+    program.addCommand(mintPolicyCmd);
+    try {
+        await program.parseAsync();
+    }
+    catch (e) {
+        console.error(e.message);
+    }
+}
+await main();

package/dist/mint.js

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { defaultWriteFunctionOptions } from "./cmds.js";
+import { getClients, stringify } from "./utils.js";
+import { getUniverseConfig } from "./config.js";
+import { parseEventLogs, parseUnits } from "viem";
+import { abi } from "./abi.js";
+export function genMintCommand() {
+    const cmd = new Command()
+        .name("mint")
+        .description("Mint an object via ObjectMinter")
+        .option("--auth <data>", "authorization data, if needed for a permissioned mint", "0x")
+        .option("--policy <index>", "the index number of the mint policy", "0")
+        .option("--value <amount>", "the amount of ETH to send together", "0")
+        .argument("<sid>", "scoped object ID, in form of set.id (e.g., 17.1)")
+        .argument("<to>", "address of the recipient")
+        .argument("[data]", "additional mint data", "0x")
+        .action(action);
+    defaultWriteFunctionOptions().forEach((option) => cmd.addOption(option));
+    return cmd;
+}
+async function action() {
+    const opts = this.opts();
+    const args0 = this.args;
+    const conf = getUniverseConfig(opts);
+    const objectMinter = conf.contracts["ObjectMinter"];
+    const setRegistry = conf.contracts["SetRegistry"];
+    const { publicClient, walletClient } = await getClients(conf, opts);
+    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 { request } = await publicClient.simulateContract({
+        address: objectMinter,
+        abi: abi.mint,
+        functionName: "mint",
+        args: [
+            args0[1],
+            setContract,
+            BigInt(id),
+            (args0[2] || "0x"),
+            opts.auth || "0x",
+            Number(opts.policy || "0"),
+        ],
+        account,
+        value,
+    });
+    const hash = await walletClient.writeContract(request);
+    console.log(`Transaction sent: ${hash}`);
+    console.log("Transaction mining...");
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    console.log("Transaction mined");
+    if (receipt.logs && receipt.logs.length > 0) {
+        const parsedLogs = parseEventLogs({ abi: abi.mint, logs: receipt.logs });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parsedLogs.forEach((log) => {
+            console.log(" - Event", log.eventName, stringify(log.args));
+        });
+    }
+}

package/dist/relate.js

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import { defaultWriteFunctionOptions } from "./cmds.js";
+import { getClients, stringify } from "./utils.js";
+import { getUniverseConfig } from "./config.js";
+import { parseEventLogs } from "viem";
+import { abi } from "./abi.js";
+export function genRelateCommand() {
+    const cmd = new Command()
+        .name("relate")
+        .description("Link a tail object to a head object through a relation")
+        .argument("<tail>", "tail node, in form of [[data.]grant.]set.id")
+        .argument("<rel>", "relation ID")
+        .argument("<head>", "head node in form of [grant.]set.id, ")
+        .action(async function () {
+        await action(this, "relate");
+    });
+    defaultWriteFunctionOptions().forEach((option) => cmd.addOption(option));
+    return cmd;
+}
+export function genUnrelateCommand() {
+    const cmd = new Command()
+        .name("unrelate")
+        .description("Unlinks a tail object from a head object")
+        .argument("<tail>", "tail node, in form of [[data.]grant.]set.id")
+        .argument("<rel>", "relation ID")
+        .argument("<head>", "head node in form of [grant.]set.id, ")
+        .action(async function () {
+        await action(this, "unrelate");
+    });
+    defaultWriteFunctionOptions().forEach((option) => cmd.addOption(option));
+    return cmd;
+}
+async function action(cmd, functionName) {
+    const opts = cmd.opts();
+    const args0 = cmd.args;
+    const conf = getUniverseConfig(opts);
+    const address = conf.contracts["OmniRegistry"];
+    const tail = parseNode4(args0[0]);
+    const rel = BigInt(args0[1]);
+    const head = parseNode3(args0[2]);
+    await sendTransaction(conf, opts, address, abi.relation, functionName, [tail, rel, head]);
+}
+async function sendTransaction(conf, opts, address, abi /* eslint-disable-line @typescript-eslint/no-explicit-any*/, functionName, args /* eslint-disable-line @typescript-eslint/no-explicit-any*/) {
+    const { publicClient, walletClient } = await getClients(conf, opts);
+    const { request } = await publicClient.simulateContract({
+        address,
+        abi,
+        functionName: "relate",
+        args,
+        account: walletClient.account,
+    });
+    const hash = await walletClient.writeContract(request);
+    console.log(`Transaction sent: ${hash}`);
+    console.log("Transaction mining...");
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    console.log("Transaction mined");
+    if (receipt.logs && receipt.logs.length > 0) {
+        const parsedLogs = parseEventLogs({ abi: abi.relation, logs: receipt.logs });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parsedLogs.forEach((log) => {
+            console.log(" - Event", log.eventName, stringify(log.args));
+        });
+    }
+}
+function parseNode4(arg) {
+    const parts = arg.split(".");
+    let [data, grant, set, id] = [0n, 0n, 0n, 0n];
+    if (parts.length == 2) {
+        set = BigInt(parts[0]);
+        id = BigInt(parts[1]);
+    }
+    else if (parts.length == 3) {
+        grant = BigInt(parts[0]);
+        set = BigInt(parts[1]);
+        id = BigInt(parts[2]);
+    }
+    else if (parts.length == 4) {
+        data = BigInt(parts[0]);
+        grant = BigInt(parts[1]);
+        set = BigInt(parts[2]);
+        id = BigInt(parts[3]);
+    }
+    else {
+        throw new Error("");
+    }
+    return (data << 192n) | (grant << 128n) | (set << 64n) | id;
+}
+function parseNode3(arg) {
+    const parts = arg.split(".");
+    let [grant, set, id] = [0n, 0n, 0n];
+    if (parts.length == 2) {
+        set = BigInt(parts[0]);
+        id = BigInt(parts[1]);
+    }
+    else if (parts.length == 3) {
+        grant = BigInt(parts[0]);
+        set = BigInt(parts[1]);
+        id = BigInt(parts[2]);
+    }
+    else {
+        throw new Error("");
+    }
+    return (grant << 128n) | (set << 64n) | id;
+}

package/dist/utils.js

@@ -0,0 +1,90 @@
+import { createPublicClient, createWalletClient, encodeAbiParameters, http } from "viem";
+import { formatAbiParameter } from "abitype";
+import fs from "fs";
+import path from "path";
+import { Wallet } from "ethers";
+import { privateKeyToAccount } from "viem/accounts";
+import promptSync from "prompt-sync";
+import os from "os";
+import JSON5 from "json5";
+import { fileURLToPath } from "url";
+export const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function version() {
+    const pkgPath = path.resolve(__dirname, "../package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+}
+export function lstrip(prefix) {
+    return function (func) {
+        return func.name.startsWith(prefix) ? func.name.substring(prefix.length).toLowerCase() : func.name;
+    };
+}
+export function rstrip(postfix) {
+    return function (func) {
+        return func.name.endsWith(postfix) ? func.name.slice(0, -postfix.length) : func.name;
+    };
+}
+export function startsWith(prefix) {
+    return function (func) {
+        return func.name.startsWith(prefix);
+    };
+}
+export function excludes(names) {
+    return function (func) {
+        return !names.includes(func.name);
+    };
+}
+export function includes(names) {
+    return function (f) {
+        return names.includes(f.name);
+    };
+}
+export function stringify(o) {
+    const replacer = (_key, value) => (typeof value === "bigint" ? value.toString() : value);
+    return JSON5.stringify(o, replacer);
+}
+export async function getClients(uniConf, opts) {
+    const transport = http(uniConf.rpcUrl);
+    const publicClient = createPublicClient({ transport });
+    const privateKey = await readPrivateKey(opts);
+    const account = privateKeyToAccount(privateKey);
+    const walletClient = createWalletClient({ account, transport });
+    return { publicClient, walletClient };
+}
+export async function readPrivateKey(opts) {
+    if (opts.privateKey) {
+        return opts.privateKey.startsWith("0x") ? opts.privateKey : `0x${opts.privateKey}`;
+    }
+    else if (opts.account) {
+        const keystorePath = path.join(os.homedir(), opts.foundry ? ".foundry" : ".every", "keystores", opts.account);
+        const keystore = JSON.parse(fs.readFileSync(keystorePath, "utf8"));
+        const password = opts.password
+            ? opts.password
+            : opts.passwordFile
+                ? fs.readFileSync(opts.passwordFile, "utf8").trim()
+                : keystore.crypto
+                    ? promptSync({ sigint: true })("Enter password to decrypt keystore: ", { echo: "" })
+                    : undefined;
+        const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keystore), password);
+        return wallet.privateKey;
+    }
+    else {
+        throw new Error(`--account or --private-key not specified`);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function checkArguments(raw, func) {
+    return raw.map((rawArg, index) => {
+        const abiParam = func.inputs[index];
+        const pt = abiParam?.type;
+        const arg = pt === "address" || pt.startsWith("bytes") || pt === "string" ? rawArg : JSON5.parse(rawArg);
+        try {
+            encodeAbiParameters([abiParam], [arg]);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                throw new Error(`invalid param ${formatAbiParameter(abiParam)}\n${e.message}`);
+            }
+        }
+        return arg;
+    });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@everyprotocol/every-cli",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "dist/",
+    "abis/",
+    ".every.toml",
+    "LICENSE",
+    "README.md"
+  ],
+  "bin": {
+    "every": "./dist/index.js"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@types/bun": "latest",
+    "@types/lodash-es": "^4.17.12",
+    "@types/prompt-sync": "^4.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "eslint": "^9.26.0",
+    "globals": "^16.1.0",
+    "typescript-eslint": "^8.32.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "commander": "^13.1.0",
+    "ethers": "^6.14.0",
+    "json5": "^2.2.3",
+    "lodash-es": "^4.17.21",
+    "prompt-sync": "^4.2.0",
+    "viem": "^2.29.1"
+  },
+  "scripts": {
+    "build": "npm run tsc -b",
+    "clean": "rm -rf dist",
+    "bb": "bun build src/*.ts --target=node --outdir dist",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}