@everyprotocol/every-cli 0.1.1 → 0.1.3

package/dist/abi.js

@@ -31,6 +31,11 @@ export const abi = {
             "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"]),
+        ...loadNonFuncAbiItems("ISet"),
     ],
     relation: [
         ...parseAbi([

package/dist/cmdgen.js

@@ -71,7 +71,7 @@ const setContractObjectCmdConfig = {
         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 publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
         const address = (await publicClient.readContract({
             address: ctx.conf.contracts["SetRegistry"],
             abi: abi.setContract,
@@ -85,7 +85,7 @@ 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 publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
     const address = (await publicClient.readContract({
         address: ctx.conf.contracts["SetRegistry"],
         abi: abi.setContract,

package/dist/cmds.js

@@ -1,11 +1,11 @@
 import { Argument, Command, Option } from "commander";
 import { createPublicClient, http, parseEventLogs, stringify } from "viem";
 import { getUniverseConfig } from "./config.js";
-import { checkArguments, getClients } from "./utils.js";
+import { checkArguments, getClientsEth } 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"));
+    options.push(new Option("--dry-run", "Simulate the command without sending a transaction"));
     return options;
 }
 export function defaultWriteFunctionOptions() {
@@ -14,9 +14,9 @@ export function defaultWriteFunctionOptions() {
     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"));
+    options.push(new Option("--password-file <file>", "file containing the password to decrypt the keystore"));
+    options.push(new Option("-f, --foundry", "use keystore from Foundry directory (~/.foundry/keystores)"));
+    options.push(new Option("--dry-run", "Simulate the command without sending a transaction"));
     return options;
 }
 const defaultConfig = {
@@ -40,12 +40,12 @@ const defaultConfig = {
         const abi = [ctx.txnAbi, ...ctx.nonFuncs];
         const functionName = ctx.txnAbi.name;
         if (isRead) {
-            const publicClient = createPublicClient({ transport: http(ctx.conf.rpcUrl) });
+            const publicClient = createPublicClient({ transport: http(ctx.conf.rpc) });
             const result = await publicClient.readContract({ address, abi, functionName, args });
             console.log(`Result:`, result);
         }
         else {
-            const { publicClient, walletClient } = await getClients(ctx.conf, opts);
+            const { publicClient, walletClient } = await getClientsEth(ctx.conf, opts);
             const account = walletClient.account;
             console.log({
                 isRead,

package/dist/config.js

@@ -2,7 +2,93 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { parse as parseTOML } from "@iarna/toml";
+import * as TOML from "@iarna/toml";
 import { __dirname } from "./utils.js";
+// export interface Universe {
+//   name: string;
+//   id: number;
+//   rpc: string;
+//   explorer: string;
+//   observer: string;
+//   contracts: {
+//     setRegistry: string;
+//     omniRegistry: string;
+//     kindRegistry: string;
+//     elementRegistry: string;
+//     objectMinter: string;
+//   };
+// }
+// export interface Observer {
+//   name: string;
+//   rpc: string;
+//   explorer: string;
+//   gateway: string;
+// }
+// export interface Config {
+//   universes: Record<string, Universe>;
+//   observers: Record<string, Observer>;
+// }
+import { z } from "zod";
+export const ContractsSchema = z.object({
+    SetRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Must be an Ethereum address"),
+    OmniRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    KindRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    ElementRegistry: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    ObjectMinter: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+});
+export const UniverseSchema = z.object({
+    id: z.number().int().nonnegative(),
+    rpc: z.string().url(),
+    explorer: z.string().url(),
+    observer: z.string(), // reference to an Observer key
+    contracts: ContractsSchema,
+});
+export const ObserverSchema = z.object({
+    rpc: z.string().url(),
+    explorer: z.string().url(),
+    gateway: z.string().url(),
+});
+export const ConfigSchema = z.object({
+    universes: z.record(UniverseSchema),
+    observers: z.record(ObserverSchema),
+});
+export function loadConfig(file) {
+    const text = fs.readFileSync(file, "utf8");
+    const raw = TOML.parse(text);
+    return ConfigSchema.parse(raw);
+}
+const configPaths = [
+    path.resolve(__dirname, "../.every.toml"),
+    path.resolve(os.homedir(), ".every.toml"),
+    path.resolve(process.cwd(), ".every.toml"),
+];
+export function loadMergedConfig() {
+    const merged = { universes: {}, observers: {} };
+    const existingFiles = configPaths.filter((f) => fs.existsSync(f));
+    if (existingFiles.length === 0) {
+        throw new Error(`No config file found. Searched in:\n  ${configPaths.join("\n  ")}`);
+    }
+    for (const file of existingFiles) {
+        const raw = loadConfig(file);
+        if (raw.universes) {
+            for (const [name, uni] of Object.entries(raw.universes)) {
+                merged.universes[name] = {
+                    ...(merged.universes[name] ?? {}),
+                    ...uni, // shallow merge here
+                };
+            }
+        }
+        if (raw.observers) {
+            for (const [name, obs] of Object.entries(raw.observers)) {
+                merged.observers[name] = {
+                    ...(merged.observers[name] ?? {}),
+                    ...obs,
+                };
+            }
+        }
+    }
+    return ConfigSchema.parse(merged);
+}
 // Cache
 let CONFIG_CACHED = null;
 export function getUniverseConfig(opts) {
@@ -39,7 +125,10 @@ function loadProtocolConfig() {
                     // console.log(name, uni);
                     mergedConfig.universes[name] = {
                         name: name,
-                        rpcUrl: uni.rpc_url,
+                        id: uni.id,
+                        rpc: uni.rpc,
+                        explorer: uni.explorer,
+                        observer: uni.observer,
                         contracts: uni.contracts || {},
                     };
                 }

package/dist/index.js

@@ -1,43 +1,8 @@
 #!/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);
-    }
+import { program } from "./program.js";
+try {
+    await program.parseAsync();
+}
+catch (e) {
+    console.error(e.message);
 }
-await main();

package/dist/keystore.js

@@ -0,0 +1,120 @@
+import { Keyring } from "@polkadot/keyring";
+import { u8aToHex, hexToU8a, isHex } from "@polkadot/util";
+import { base64Decode, cryptoWaitReady } from "@polkadot/util-crypto";
+import { privateKeyToAccount } from "viem/accounts";
+import { Wallet } from "ethers";
+import { decodePair } from "@polkadot/keyring/pair/decode";
+function isSubstrateJson(obj) {
+    return !!obj?.encoded && !!obj?.encoding && !!obj?.encoding?.content;
+}
+function isWeb3V3Json(obj) {
+    return Number(obj?.version) === 3 && !!obj?.crypto;
+}
+function inferSubstrateKeyType(obj) {
+    const content = Array.isArray(obj.encoding.content) ? obj.encoding.content : [obj.encoding.content];
+    // Typical values: ["pkcs8","sr25519"] | ["pkcs8","ed25519"] | ["pkcs8","ecdsa"] | ["pkcs8","ethereum"]
+    if (content.includes("sr25519"))
+        return "sr25519";
+    if (content.includes("ed25519"))
+        return "ed25519";
+    if (content.includes("ecdsa"))
+        return "ecdsa";
+    if (content.includes("ethereum"))
+        return "ethereum";
+    // Default to sr25519 if not specified (common in older exports)
+    return "sr25519";
+}
+function decryptSubstrate(keystore, password = "") {
+    const encodedRaw = keystore.encoded;
+    const types = keystore.encoding.type;
+    const encodingTypes = Array.isArray(types) ? types : [types];
+    const encoded = isHex(encodedRaw) ? hexToU8a(encodedRaw) : base64Decode(encodedRaw);
+    const decoded = decodePair(password, encoded, encodingTypes /*eslint-disable-line @typescript-eslint/no-explicit-any*/);
+    return decoded.secretKey;
+}
+async function decryptWeb3V3(keystore, password = "") {
+    const w = await Wallet.fromEncryptedJson(JSON.stringify(keystore), password);
+    return hexToU8a(w.privateKey);
+}
+export class UnifiedKeystore {
+    _keystore;
+    _type;
+    _keyType;
+    _password;
+    _pair; // cached for all key types
+    _account; // cached for ethereum keys (viem)
+    _privateKey; // cached decrypted private key
+    constructor(type, keyType, keystore, password) {
+        this._keystore = keystore;
+        this._type = type;
+        this._keyType = keyType;
+        this._password = password;
+    }
+    static async fromJSON(keystore, password) {
+        await cryptoWaitReady();
+        const obj = typeof keystore === "string" ? JSON.parse(keystore) : keystore;
+        if (isSubstrateJson(obj)) {
+            const keyType = inferSubstrateKeyType(obj);
+            return new UnifiedKeystore("substrate", keyType, obj, password);
+        }
+        if (isWeb3V3Json(obj)) {
+            return new UnifiedKeystore("web3_v3", "ethereum", obj, password);
+        }
+        throw new Error("Unsupported keystore JSON: expected Substrate (pkcs8) or Web3 v3 keystore");
+    }
+    type() {
+        return this._type;
+    }
+    keyType() {
+        return this._keyType;
+    }
+    async address() {
+        return (await this.pair()).address;
+    }
+    async publicKey() {
+        return (await this.pair()).publicKey;
+    }
+    async privateKey() {
+        if (this._privateKey)
+            return this._privateKey;
+        if (this._type === "substrate") {
+            this._privateKey = decryptSubstrate(this._keystore, this._password ?? "");
+        }
+        else {
+            this._privateKey = await decryptWeb3V3(this._keystore, this._password ?? "");
+        }
+        return this._privateKey;
+    }
+    async pair() {
+        if (this._pair)
+            return this._pair;
+        const keyring = new Keyring({ type: this._keyType });
+        if (this._type === "substrate") {
+            const pair = keyring.addFromJson(this._keystore);
+            if (this._password !== undefined) {
+                try {
+                    pair.unlock(this._password);
+                }
+                catch {
+                    // If password is wrong/empty, leave it locked; address/publicKey still work.
+                }
+            }
+            this._pair = pair;
+        }
+        else {
+            const sk = await this.privateKey();
+            this._pair = keyring.addFromUri(u8aToHex(sk));
+        }
+        return this._pair;
+    }
+    async account() {
+        if (this._keyType !== "ethereum") {
+            throw new Error("accounts() is only available for ethereum keys");
+        }
+        if (this._account)
+            return this._account;
+        const sk = await this.privateKey();
+        this._account = privateKeyToAccount(u8aToHex(sk));
+        return this._account;
+    }
+}

package/dist/matter.js

@@ -0,0 +1,96 @@
+import { Command } from "commander";
+import { ApiPromise, WsProvider } from "@polkadot/api";
+import "@polkadot/api-augment/substrate";
+import * as fs from "fs";
+import * as path from "path";
+import { getObserverConfig, keystoreFromOptions } from "./utils.js";
+import "./options.js";
+import { findEvent, submitTransaction } from "./substrate.js";
+import JSON5 from "json5";
+function guessContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".txt":
+            return "text/plain";
+        case ".json":
+            return "application/json";
+        case ".wasm":
+            return "application/wasm";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function genMatterCommand() {
+    const cmd = new Command().name("matter").description("manage matters");
+    cmd
+        .command("register")
+        .description("Register matter on the Substrate chain")
+        .argument("<files...>", "Path to the file(s) containing the matter content")
+        .option("-c, --content-type <type>", "Default content type")
+        .option("-h, --hasher <number>", "Default hasher", "1")
+        .option("-u, --universe <name>", "Universe name")
+        .option("-o, --observer <name>", "Observer name")
+        .accountOptions()
+        .action(async (files, options) => {
+        const materials = [];
+        // Process each file argument
+        for (const file of files) {
+            const [filePath, hasher_, contentType_] = file.split(":");
+            const hasher = hasher_ ? Number(hasher_) : Number(options.hasher) || 1;
+            const contentType = contentType_ || options.contentType || guessContentType(filePath);
+            materials.push({ filePath, hasher, contentType });
+        }
+        const conf = getObserverConfig(options);
+        const keystore = await keystoreFromOptions(options);
+        const pair = await keystore.pair();
+        // Connect to the Substrate node
+        // console.log(`Connecting to ${conf.rpc}...`);
+        const provider = new WsProvider(conf.rpc);
+        const api = await ApiPromise.create({ provider });
+        await api.isReady;
+        // console.log("Connected to Substrate node");
+        const txns = [];
+        // Submit transactions for each material
+        for (const { filePath, hasher, contentType } of materials) {
+            console.log(`Processing ${filePath}: content-type=${contentType}, hasher=${hasher}`);
+            const content = fs.readFileSync(filePath);
+            const contentRaw = api.createType("Raw", content, content.length);
+            const call = api.tx.every.matterRegister(hasher, contentType, contentRaw);
+            console.log(`Submitting transaction for ${filePath}...`);
+            const txn = await submitTransaction(api, call, pair);
+            console.log(`Transaction submitted: ${txn.txHash}`);
+            txns.push({ txn, filePath });
+        }
+        // Wait for all transactions to be finalized
+        for (const { txn, filePath } of txns) {
+            console.log(`Waiting for ${filePath} to be finalized...`);
+            const receipt = await txn.receipt;
+            const event = findEvent(receipt.events, "MaterialAdded");
+            if (event) {
+                const hash = event.data[0].toString();
+                console.log(`${filePath} finalized in block ${receipt.blockHash}`);
+                console.log(`  Matter hash: ${hash}`);
+                if (conf.gateway) {
+                    console.log(`  Preimage: ${conf.gateway}/m/${hash}`);
+                }
+                if (conf.explorer) {
+                    // console.log(`  Transaction: ${conf.explorer}/extrinsic/${receipt.blockNumber}-${receipt.txIndex}`);
+                }
+            }
+            else {
+                console.log(`${filePath} finalized, but no MaterialAdded event found`);
+                for (const { event } of receipt.events) {
+                    console.log(`${event.method.padEnd(20)}`, JSON5.stringify(event.data.toHuman()));
+                }
+            }
+        }
+        await api.disconnect();
+        console.log("Disconnected from Substrate node");
+    });
+    return cmd;
+}

package/dist/mint.js

@@ -1,19 +1,20 @@
 import { Command } from "commander";
 import { defaultWriteFunctionOptions } from "./cmds.js";
-import { getClients, stringify } from "./utils.js";
+import { getClientsEth, 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")
+        .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")
         .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")
+        .argument("[data]", "additional input data", "0x")
         .action(action);
     defaultWriteFunctionOptions().forEach((option) => cmd.addOption(option));
     return cmd;
@@ -22,9 +23,8 @@ 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 { publicClient, walletClient } = await getClientsEth(conf, opts);
     const account = walletClient.account;
     const [set, id] = args0[0].split(".");
     const setContract = (await publicClient.readContract({
@@ -34,28 +34,42 @@ async function action() {
         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);
+    // Use the provided recipient address or default to the sender's address
+    const recipientAddress = (opts.to || account.address);
+    const mintData = (args0[1] || "0x");
+    let hash;
+    if (opts.minter) {
+        // Mint via ObjectMinter
+        const objectMinter = conf.contracts["ObjectMinter"];
+        const { request } = await publicClient.simulateContract({
+            address: objectMinter,
+            abi: abi.mint,
+            functionName: "mint",
+            args: [recipientAddress, setContract, BigInt(id), mintData, opts.auth || "0x", Number(opts.policy || "0")],
+            account,
+            value,
+        });
+        hash = await walletClient.writeContract(request);
+    }
+    else {
+        // Mint directly from set contract
+        const { request } = await publicClient.simulateContract({
+            address: setContract,
+            abi: abi.create,
+            functionName: "create",
+            args: [recipientAddress, BigInt(id), mintData],
+            account,
+            value,
+        });
+        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 });
+        const abiToUse = opts.minter ? abi.mint : abi.create;
+        const parsedLogs = parseEventLogs({ abi: abiToUse, 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/options.js

@@ -0,0 +1,26 @@
+import { Command, Option } from "commander";
+export const optRpcUrl = new Option("--rpc-url <url>", "RPC endpoint URL");
+export const optChainId = new Option("--chain-id <id>", "Chain ID").argParser(Number);
+export const optPkey = new Option("--private-key <hex>", "Sender private key");
+export const optFrom = new Option("--from <address>", "Sender address");
+export const optDerivePath = new Option("--path <hd>", "Derivation path (HD)");
+export const optVerbose = new Option("-v, --verbose", "Enable verbose logging");
+export const optSilent = new Option("--silent", "Suppress output");
+export const optAccount = new Option("-a, --account <account>", "Name of the keystore");
+export const optPassword = new Option("-p, --password [password]", "Password to decrypt the keystore");
+export const optPasswordFile = new Option("--password-file <file>", "File containing the keystore password");
+export const optFoundry = new Option("-f, --foundry", "use foundry keystores (~/.foundry/keystores)");
+export const accountOptions = [optAccount, optPassword, optPasswordFile, optFoundry];
+Command.prototype.useOptions = function (options) {
+    options.forEach((o) => this.addOption(o));
+    return this;
+};
+// (Command.prototype as unknown as Command).networkOptions = function () {
+//   return (this as Command).useOptions(networkGroup);
+// };
+Command.prototype.accountOptions = function () {
+    return this.useOptions(accountOptions);
+};
+// (Command.prototype as unknown as Command).commonOptions = function () {
+//   return (this as Command).useOptions(commonGroup);
+// };

package/dist/program.js

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { generateCommands } from "./cmdgen.js";
+import { RenamingCommand } from "./cmds.js";
+import { version } from "./utils.js";
+import { walletCmd } from "./wallet.js";
+import { genMatterCommand } from "./matter.js";
+function buildProgram() {
+    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("minter")
+        .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(genMatterCommand());
+    program.addCommand(setCmd);
+    program.addCommand(kindCmd);
+    program.addCommand(relationCmd);
+    program.addCommand(valueCmd);
+    program.addCommand(uniqueCmd);
+    program.addCommand(objectCmd);
+    program.addCommand(mintPolicyCmd);
+    program.addCommand(walletCmd);
+    return program;
+}
+export const program = buildProgram();

package/dist/relate.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { defaultWriteFunctionOptions } from "./cmds.js";
-import { getClients, stringify } from "./utils.js";
+import { getClientsEth, stringify } from "./utils.js";
 import { getUniverseConfig } from "./config.js";
 import { parseEventLogs } from "viem";
 import { abi } from "./abi.js";
@@ -41,7 +41,7 @@ async function action(cmd, functionName) {
     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 { publicClient, walletClient } = await getClientsEth(conf, opts);
     const { request } = await publicClient.simulateContract({
         address,
         abi,