@everyprotocol/every-cli 0.1.0 → 0.1.2

package/.every.toml

@@ -2,8 +2,14 @@
 # This file can be overridden by placing a .every.toml file in your home directory
 # or in the current working directory
 [universes.local]
-name = "local"
-rpc_url = "http://127.0.0.1:8545"
+id = 31337
+rpc = "http://127.0.0.1:8545"
+explorer = "http://127.0.0.1:8545"
+
+[universes.local.observer]
+rpc = "ws://localhost:9944"
+gateway = "http://every.im.local"
+explorer = "http://every.im.local"
 
 [universes.local.contracts]
 SetRegistry = "0x854C35Fd2b65fE9fcE71dddE91De8c3e1A7Dc8Ae"

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 "Every Protocol" Project Steward.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1 +1,100 @@
+# Every CLI
 
+A command-line interface for interacting with the Every Protocol.
+
+## Installation
+
+```bash
+bun add -g @everyprotocol/every-cli
+npm install -g @everyprotocol/every-cli
+```
+
+## Configuration
+
+> **Note:** You normally don’t need to configure anything manually.
+> A default configuration is bundled with support for all chains officially supported by the protocol.
+
+The CLI looks for configuration in the following locations (in order of precedence):
+1. `.every.toml` in the current directory
+2. `.every.toml` in your home directory
+3. The default configuration bundled with the package
+
+Example configuration:
+
+```toml
+[universes.local]
+rpc_url = "http://localhost:8545"
+contracts.KindRegistry = "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+contracts.SetRegistry = "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
+contracts.ElementRegistry = "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0"
+contracts.OmniRegistry = "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9"
+contracts.ObjectMinter = "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9"
+
+[universes.testnet]
+rpc_url = "https://testnet-rpc.example.com"
+contracts.KindRegistry = "0x..."
+# Add other contract addresses as needed
+```
+
+## Usage
+
+The CLI provides commands for interacting with different aspects of the Every Protocol:
+
+```bash
+every --help
+```
+
+### Main Commands
+
+- `every kind` - Manage kinds
+- `every set` - Manage sets
+- `every relation` - Manage relations
+- `every unique` - Manage uniques
+- `every value` - Manage values
+- `every object` - Create and interact with objects
+- `every mintpolicy` - Manage mint policies
+
+### Examples
+
+#### Minting an Object
+
+```bash
+every object mint 17.1 0xYourAddress
+```
+
+#### Relating objects
+
+```bash
+every object relate 17.1 42 18.2
+```
+
+#### Viewing Object Information
+
+```bash
+every object owner 17.1
+```
+
+### Signing Transactions
+
+Most write operations require signing with a wallet or private key. You can provide your private key or use a keystore:
+
+```bash
+-k, --private-key <key>       Private key to sign the transaction
+-a, --account <account>       Name of the keystore to sign the transaction
+-p, --password [password]     Password to decrypt the keystore
+-f, --password-file <file>    File containing the password to decrypt the keystore
+    --foundry                 Use keystore from Foundry directory (~/.foundry/keystores)
+```
+
+#### Using a private key
+
+```bash
+every object mint 17.1 0xRecipient --private-key 0xYourPrivateKey
+```
+#### Using a keystore
+```bash
+every object mint 17.1 0xRecipient --account myaccount
+```
+
+## License
+[MIT](LICENSE)

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

@@ -39,7 +39,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/matter.js

@@ -0,0 +1,152 @@
+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 { getUniverseConfig } from "./config.js";
+import { getSubstrateAccountPair } from "./utils.js";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { u8aFixLength } from "@polkadot/util";
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+async function submitTransaction(api, tx, pair) {
+    // const pTxn = Promise.withResolvers<Transaction>();
+    // const pReceipt = Promise.withResolvers<Receipt>();
+    const pTxn = createDeferred();
+    const pReceipt = createDeferred();
+    const accountId = u8aFixLength(decodeAddress(pair.address), 256);
+    const nonce = await api.rpc.system.accountNextIndex(accountId);
+    const unsub = await tx.signAndSend(pair, { nonce }, ({ events = [], status, txHash, txIndex, blockNumber }) => {
+        if (status.isReady) {
+            pTxn.resolve({ txHash: txHash.toHex(), receipt: pReceipt.promise });
+        }
+        else if (status.isFinalized) {
+            pReceipt.resolve({
+                txHash: txHash.toHex(),
+                blockHash: status.asFinalized.toHex(),
+                txIndex,
+                blockNumber,
+                events: events,
+            });
+            unsub();
+        }
+    });
+    return await pTxn.promise;
+}
+function findEvent(events, name) {
+    for (const record of events) {
+        if (record.event && record.event.method === name) {
+            return record.event;
+        }
+    }
+    return null;
+}
+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 <universe>", "Universe name", "local")
+        .option("-a, --account <account>", "Name of the keystore to sign the transaction")
+        .option("-p, --password [password]", "Password to decrypt the keystore")
+        .option("--password-file <file>", "File containing the password to decrypt the keystore")
+        .action(async (files, options) => {
+        const materials = [];
+        // Process each file argument
+        for (const file of files) {
+            let [filePath, hasher_, contentType] = file.split(":");
+            const hasher = hasher_ ? Number(hasher_) : Number(options.hasher) || 1;
+            if (!contentType) {
+                if (options.contentType) {
+                    contentType = options.contentType;
+                }
+                else {
+                    contentType = guessContentType(filePath);
+                }
+            }
+            materials.push({ filePath, hasher, contentType });
+        }
+        // Get universe configuration
+        const conf = getUniverseConfig(options);
+        if (!conf.observer.rpc) {
+            throw new Error("pre_rpc_url not configured in universe");
+        }
+        // Get account pair for signing
+        if (!options.account) {
+            throw new Error("Account must be specified with --account");
+        }
+        // const keystorePath = resolveKeystoreFile(options.account, options);
+        // const keystore = loadKeystore(keystorePath);
+        // const password = getPassword(options);
+        const accountPair = getSubstrateAccountPair(options);
+        // Connect to the Substrate node
+        console.log(`Connecting to ${conf.observer.rpc}...`);
+        const provider = new WsProvider(conf.observer.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.matter.register(hasher, contentType, contentRaw);
+            console.log(`Submitting transaction for ${filePath}...`);
+            const txn = await submitTransaction(api, call, accountPair);
+            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.observer.gateway) {
+                    console.log(`  Preimage: ${conf.observer.gateway}/m/${hash}`);
+                }
+                if (conf.observer.explorer) {
+                    console.log(`  Transaction: ${conf.observer.explorer}/extrinsic/${receipt.blockNumber}-${receipt.txIndex}`);
+                }
+            }
+            else {
+                console.log(`${filePath} finalized, but no MaterialAdded event found`);
+            }
+        }
+        await api.disconnect();
+        console.log("Disconnected from Substrate node");
+    });
+    return cmd;
+}

package/dist/mint.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, parseUnits } from "viem";
 import { abi } from "./abi.js";
@@ -24,7 +24,7 @@ async function action() {
     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({

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 { genWalletCommands } 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("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);
+    program.addCommand(genWalletCommands());
+    program.addCommand(genMatterCommand());
+    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,

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { createPublicClient, createWalletClient, encodeAbiParameters, http } from "viem";
+import { bytesToHex, createPublicClient, createWalletClient, encodeAbiParameters, http, } from "viem";
 import { formatAbiParameter } from "abitype";
 import fs from "fs";
 import path from "path";
@@ -8,6 +8,10 @@ import promptSync from "prompt-sync";
 import os from "os";
 import JSON5 from "json5";
 import { fileURLToPath } from "url";
+import { isHex, hexToU8a } from "@polkadot/util";
+import { base64Decode } from "@polkadot/util-crypto/base64";
+import { decodePair } from "@polkadot/keyring/pair/decode";
+import Keyring from "@polkadot/keyring";
 export const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function version() {
     const pkgPath = path.resolve(__dirname, "../package.json");
@@ -42,33 +46,45 @@ 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);
+export async function getClientsEth(uniConf, opts) {
+    const transport = http(uniConf.rpc);
     const publicClient = createPublicClient({ transport });
-    const privateKey = await readPrivateKey(opts);
+    const privateKey = await readPrivateKeyEth(opts);
     const account = privateKeyToAccount(privateKey);
     const walletClient = createWalletClient({ account, transport });
     return { publicClient, walletClient };
 }
-export async function readPrivateKey(opts) {
+export async function readPrivateKeyEth(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;
+        const keystorePath = resolveKeystoreFile(opts.account, opts);
+        const keystore = loadKeystore(keystorePath);
+        if (keystore.crypto || keystore.Crypto) {
+            // for Ethereum keystores
+            const password = getPassword(opts);
+            const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keystore), password);
+            return wallet.privateKey;
+        }
+        else if (keystore.encoding || keystore.meta) {
+            // for Substrate keystores
+            if (keystore.meta?.isEthereum || keystore.meta?.type === "ethereum") {
+                const password = getPassword(opts);
+                const pair = decodeSubstratePair(keystore, password);
+                return bytesToHex(pair.secretKey);
+            }
+            else {
+                throw new Error("Not an Ethereum account");
+            }
+        }
+        else {
+            // Not supported for now
+            throw new Error("Unknown keystore format");
+        }
     }
     else {
-        throw new Error(`--account or --private-key not specified`);
+        throw new Error(`Neither account nor private key specified`);
     }
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -88,3 +104,78 @@ export function checkArguments(raw, func) {
         return arg;
     });
 }
+export function resolveKeystoreDir(options) {
+    if (options.foundry) {
+        return path.join(os.homedir(), ".foundry", "keystores");
+    }
+    if (options.dir) {
+        return options.dir;
+    }
+    return path.join(os.homedir(), ".every", "keystores");
+}
+export function resolveKeystoreFile(name, options) {
+    const dir = resolveKeystoreDir(options);
+    return path.join(dir, name);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function saveKeystore(json, name, options) {
+    const dir = resolveKeystoreDir(options);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const file = path.join(dir, name);
+    if (fs.existsSync(file)) {
+        throw new Error(`File exists: ${file}`);
+    }
+    fs.writeFileSync(file, JSON.stringify(json));
+    console.log(`File saved: ${file}`);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function loadKeystore(file) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`Keystore file not found: ${file}`);
+    }
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+export function getPassword(opts) {
+    return opts.password
+        ? opts.password
+        : opts.passwordFile
+            ? fs.readFileSync(opts.passwordFile, "utf8").trim()
+            : promptSync({ sigint: true })("Password: ", { echo: "" });
+}
+export function getPasswordConfirm(opts) {
+    if (opts.password) {
+        return opts.password;
+    }
+    if (opts.passwordFile) {
+        return fs.readFileSync(opts.passwordFile, "utf8").trim();
+    }
+    const prompt = promptSync({ sigint: true });
+    const password = prompt("Password: ", { echo: "" });
+    const confirmation = prompt("Confirm: ", { echo: "" });
+    if (password !== confirmation) {
+        throw new Error(`Error: Passwords do not match`);
+    }
+    return password;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function decodeSubstratePair(keystore, password) {
+    const encodedRaw = keystore.encoded;
+    let encodingType = keystore.encoding.type;
+    encodingType = !Array.isArray(encodingType) ? [encodingType] : encodingType;
+    const encoded = isHex(encodedRaw) ? hexToU8a(encodedRaw) : base64Decode(encodedRaw);
+    const decoded = decodePair(password, encoded, encodingType);
+    return decoded;
+}
+export function getSubstrateAccountPair(flags) {
+    const keyFile = resolveKeystoreFile(flags.account, flags);
+    const keyData = loadKeystore(keyFile);
+    const keyring = new Keyring();
+    const pair = keyring.createFromJson(keyData);
+    if (pair.isLocked) {
+        const password = getPassword(flags);
+        pair.unlock(password);
+    }
+    return pair;
+}

package/dist/wallet.js

@@ -0,0 +1,108 @@
+import { Command } from "commander";
+import { Keyring } from "@polkadot/keyring";
+import { mnemonicGenerate, cryptoWaitReady } from "@polkadot/util-crypto";
+import { bytesToHex } from "viem";
+import * as fs from "fs";
+import { decodeSubstratePair, getPassword, getPasswordConfirm, loadKeystore, resolveKeystoreDir, resolveKeystoreFile, saveKeystore, } from "./utils.js";
+// Wallet commands
+export function genWalletCommands() {
+    const walletCmd = new Command().name("wallet").description("manage wallets");
+    // List command
+    const listCmd = new Command()
+        .name("list")
+        .description("List all wallets")
+        .option("--foundry", "use foundry keystore directory (~/.foundry/keystores)")
+        .option("--dir <dir>", "specify a custom keystore directory")
+        .action(async (options) => {
+        const dir = resolveKeystoreDir(options);
+        const files = fs.readdirSync(dir);
+        files.forEach((file) => console.log(file));
+    });
+    // Generate command
+    const generateCmd = new Command()
+        .name("new")
+        .description("Generate a new wallet")
+        .option("-t, --type <type>", "key type (ed25519, sr25519, ethereum)", "sr25519")
+        .option("-p, --password <password>", "password to encrypt the keystore")
+        .option("-P, --password-file <file>", "password file")
+        .option("--dir <dir>", "specify keystore directory")
+        .option("--foundry", "use foundry keystore directory (~/.foundry/keystores)")
+        .argument("<name>", "name of the wallet")
+        .action(async (name, options) => {
+        const password = getPasswordConfirm(options);
+        await cryptoWaitReady();
+        const keyring = new Keyring();
+        const mnemonic = mnemonicGenerate();
+        const pair = keyring.addFromUri(mnemonic, { name }, options.type);
+        const json = pair.toJson(password);
+        saveKeystore(json, name, options);
+    });
+    // Import command
+    const importCmd = new Command()
+        .name("import")
+        .description("Import a wallet from a secrete URI")
+        .option("-t, --type <type>", "key type (sr25519, ed25519, ethereum)", "sr25519")
+        .option("-p, --password <password>", "password to encrypt the keystore")
+        .option("-P, --password-file <file>", "password file")
+        .option("--dir <dir>", "specify a custom keystore directory")
+        .option("--foundry", "use foundry keystore directory (~/.foundry/keystores)")
+        .argument("<name>", "name of the wallet")
+        .argument("<suri>", "secret URI")
+        .action(async (name, suri, options) => {
+        const password = getPasswordConfirm(options);
+        await cryptoWaitReady();
+        const keyring = new Keyring({ type: options.type });
+        const pair = keyring.addFromUri(suri);
+        const json = pair.toJson(password);
+        saveKeystore(json, name, options);
+    });
+    // Inspect command
+    const inspectCmd = new Command()
+        .name("inspect")
+        .description("Inspect a wallet")
+        .option("-t, --type <type>", "key type (sr25519, ed25519, ethereum)", "sr25519")
+        .option("-p, --password <password>", "password to decrypt the keystore")
+        .option("-P, --password-file <file>", "file containing the password")
+        .option("-x, --decrypt", "also decrypt the private key", false)
+        .option("--dir <dir>", "specify a custom keystore directory")
+        .option("--foundry", "use foundry keystore directory (~/.foundry/keystores)")
+        .argument("<name>", "name of the wallet")
+        .action(async (name, options) => {
+        const file = resolveKeystoreFile(name, options);
+        const keyData = loadKeystore(file);
+        await cryptoWaitReady();
+        const keyring = new Keyring({ type: options.type });
+        const account = keyring.addFromJson(keyData);
+        let password;
+        if (account.isLocked) {
+            password = getPassword(options);
+            account.unlock(password);
+        }
+        let decoded;
+        if (options.decrypt) {
+            decoded = decodeSubstratePair(keyData, password);
+        }
+        let keystoreDisplay = "~/.every/keystores";
+        if (options.foundry) {
+            keystoreDisplay = "~/.foundry/keystores";
+        }
+        else if (options.dir) {
+            keystoreDisplay = options.dir;
+        }
+        console.log(`  Keystore: ${keystoreDisplay}`);
+        console.log(`    Wallet: ${name}`);
+        console.log(`      Type: ${account.type}`);
+        console.log(`      Meta: ${JSON.stringify(account.meta)}`);
+        console.log(`   Address: ${account.address}`);
+        console.log(`AddressRaw: ${bytesToHex(account.addressRaw)}`);
+        console.log(` PublicKey: ${bytesToHex(account.publicKey)}`);
+        if (decoded) {
+            console.log(`SecretKey: ${bytesToHex(decoded.secretKey)}`);
+        }
+    });
+    walletCmd.addCommand(listCmd);
+    walletCmd.addCommand(generateCmd);
+    walletCmd.addCommand(importCmd);
+    walletCmd.addCommand(inspectCmd);
+    return walletCmd;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "files": [
     "dist/",
     "abis/",
@@ -28,6 +28,10 @@
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
+    "@polkadot/api": "^16.2.2",
+    "@polkadot/keyring": "^13.5.2",
+    "@polkadot/util": "^13.5.2",
+    "@polkadot/util-crypto": "^13.5.2",
     "commander": "^13.1.0",
     "ethers": "^6.14.0",
     "json5": "^2.2.3",