@everyprotocol/every-cli 0.1.1 → 0.1.3

package/dist/substrate.js

@@ -0,0 +1,57 @@
+import "@polkadot/api-augment/substrate";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { u8aFixLength } from "@polkadot/util";
+import "./options.js";
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+export 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 }, (result) => {
+        const { status, txHash, events, dispatchError } = result;
+        if (dispatchError) {
+            if (dispatchError.isModule) {
+                const meta = api.registry.findMetaError(dispatchError.asModule);
+                const msg = `${meta.section}.${meta.name}${meta.docs.length ? `: ${meta.docs.join(" ")}` : ""}`;
+                unsub();
+                pReceipt.reject(new Error(`DispatchError: ${msg}`));
+            }
+            else {
+                unsub();
+                pReceipt.reject(new Error(dispatchError.toString()));
+            }
+        }
+        if (status.isReady) {
+            pTxn.resolve({ txHash: txHash.toHex(), receipt: pReceipt.promise });
+        }
+        if (status.isFinalized) {
+            unsub();
+            pReceipt.resolve({
+                txHash: txHash.toHex(),
+                blockHash: status.asFinalized.toHex(),
+                events: events,
+                result,
+            });
+        }
+    });
+    return await pTxn.promise;
+}
+export function findEvent(events, name) {
+    for (const record of events) {
+        if (record.event && record.event.method === name) {
+            return record.event;
+        }
+    }
+    return undefined;
+}

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,12 @@ 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 { loadMergedConfig } from "./config.js";
+import Keyring from "@polkadot/keyring";
+import { UnifiedKeystore } from "./keystore.js";
 export const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export function version() {
     const pkgPath = path.resolve(__dirname, "../package.json");
@@ -42,33 +48,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 +106,117 @@ 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;
+}
+export async function keystoreFromOptions(options) {
+    if (!options.account) {
+        throw new Error("Account must be specified with --account");
+    }
+    return keystoreFromAccount(options.account, options);
+}
+export async function keystoreFromAccount(account, options) {
+    const file = resolveKeystoreFile(account, options);
+    const keyData = loadKeystore(file);
+    const password = getPassword(options);
+    const keystore = await UnifiedKeystore.fromJSON(keyData, password);
+    return keystore;
+}
+export function getObserverConfig(options) {
+    const conf = loadMergedConfig();
+    let observerName;
+    const DEFAULT_OBSERVER = "localnet";
+    if (options.observer) {
+        observerName = options.observer;
+    }
+    else if (options.universe) {
+        const universe = conf.universes[options.universe];
+        if (!universe) {
+            throw new Error(`Universe '${options.universe}' not found in config. Available: ${Object.keys(conf.universes).join(", ")}`);
+        }
+        observerName = universe.observer;
+    }
+    else {
+        observerName = DEFAULT_OBSERVER;
+    }
+    if (!observerName) {
+        throw new Error(`No observer resolved from options or config.`);
+    }
+    const observer = conf.observers[observerName];
+    if (!observer) {
+        throw new Error(`Observer '${observerName}' not found in config. Available: ${Object.keys(conf.observers).join(", ")}`);
+    }
+    return observer;
+}

package/dist/wallet.js

@@ -0,0 +1,90 @@
+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 { getPasswordConfirm, keystoreFromAccount, resolveKeystoreDir, saveKeystore } from "./utils.js";
+const listCmd = new Command()
+    .name("list")
+    .description("List all wallets")
+    .option("-f, --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));
+});
+const generateCmd = new Command()
+    .name("new")
+    .description("Generate a new wallet")
+    .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 keystore directory")
+    .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);
+});
+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("-f, --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);
+});
+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("-f, --foundry", "use foundry keystore directory (~/.foundry/keystores)")
+    .argument("<name>", "name of the wallet")
+    .action(async (name, options) => {
+    const keystore = await keystoreFromAccount(name, options);
+    let decoded;
+    if (options.decrypt) {
+        decoded = await keystore.privateKey();
+    }
+    let dir = "~/.every/keystores";
+    if (options.foundry) {
+        dir = "~/.foundry/keystores";
+    }
+    else if (options.dir) {
+        dir = options.dir;
+    }
+    console.log(`   Keystore: ${dir}/${name}`);
+    console.log(` Store Type: ${keystore.type()}`);
+    console.log(`   Key Type: ${keystore.keyType()}`);
+    console.log(`    Address: ${await keystore.address()}`);
+    console.log(` Public Key: ${bytesToHex(await keystore.publicKey())}`);
+    if (decoded) {
+        console.log(`Private Key: ${bytesToHex(decoded)}`);
+    }
+});
+export const walletCmd = new Command()
+    .name("wallet")
+    .description("manage wallets")
+    .addCommand(listCmd)
+    .addCommand(generateCmd)
+    .addCommand(importCmd)
+    .addCommand(inspectCmd);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",