@everyprotocol/every-cli 0.1.1 → 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/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.1",
+  "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",