@everyprotocol/every-cli 0.1.2 → 0.1.4

package/dist/cmds/unique.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `unique`),
+    getAbiFuncs: (funcName) => abi.funcs.elemRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.elemRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.ElementRegistry,
+};
+const cmdGen = getCommandGen(cmdGenConfig);
+const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot".split(",");
+export const uniqueCmd = new Command("unique").description("manage uniques").addCommands(subCmds.map(cmdGen));

package/dist/cmds/universe.js

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import "@polkadot/api-augment/substrate";
+import { submitSubTxUI } from "../substrate.js";
+import { network } from "../commander-patch.js";
+import { parseAccountId, parseBigInt } from "../parsers.js";
+import { Logger } from "../logger.js";
+const universeStartCmd = new Command("start")
+    .description("Start a universe")
+    .argument("<universe>", "Universe ID", parseBigInt)
+    .argument("<horizon>", "Block number", parseBigInt)
+    .argument("<herald>", "Herald address (SS58 or 0x hex)", parseAccountId)
+    .addOption(network)
+    .addKeystoreOptions()
+    .addOutputOptions()
+    .subWriteAction(async function (api, pair, universe, horizon, herald) {
+    const call = api.tx.every.canonicalStart(universe, horizon, herald);
+    const tx = api.tx.sudo.sudo(call);
+    const console = new Logger(this.opts());
+    await submitSubTxUI(api, tx, pair, console);
+});
+export const universeCmd = new Command("universe").description("manage universes").addCommand(universeStartCmd);

package/dist/cmds/value.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { abi } from "../abi.js";
+import { getCommandGen, makeFuncName } from "../cmdgen.js";
+const cmdGenConfig = {
+    getFuncName: (cmdName) => makeFuncName(cmdName, `value`),
+    getAbiFuncs: (funcName) => abi.funcs.elemRegistry.filter((i) => i.name == funcName),
+    // eslint-disable-next-line
+    getAbiNonFuncs: (funcName) => abi.nonFuncs.elemRegistry,
+    // eslint-disable-next-line
+    getContract: (conf, args, abiFunc) => conf.contracts.ElementRegistry,
+};
+const cmdGen = getCommandGen(cmdGenConfig);
+const subCmds = "register,upgrade,touch,transfer,owner,descriptor,snapshot".split(",");
+export const valueCmd = new Command("value").description("manage values").addCommands(subCmds.map(cmdGen));

package/dist/cmds/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 { FromOpts } from "../from-opts.js";
+import { saveJson } from "../utils.js";
+const walletListCmd = 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 = FromOpts.getKeystoreDir(options);
+    const files = fs.readdirSync(dir);
+    files.forEach((file) => console.log(file));
+});
+const walletNewCmd = 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 = FromOpts.confirmPassword(options);
+    await cryptoWaitReady();
+    const keyring = new Keyring();
+    const mnemonic = mnemonicGenerate();
+    const pair = keyring.addFromUri(mnemonic, { name }, options.type);
+    const json = pair.toJson(password);
+    const dir = FromOpts.getKeystoreDir(options);
+    saveJson(json, dir, name);
+});
+const walletImportCmd = 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 = FromOpts.confirmPassword(options);
+    await cryptoWaitReady();
+    const keyring = new Keyring({ type: options.type });
+    const pair = keyring.addFromUri(suri);
+    const json = pair.toJson(password);
+    const dir = FromOpts.getKeystoreDir(options);
+    saveJson(json, dir, name);
+});
+const walletInspectCmd = 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 FromOpts.getKeystore(options, name);
+    const decoded = options.decrypt ? await keystore.privateKey() : undefined;
+    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(walletListCmd)
+    .addCommand(walletNewCmd)
+    .addCommand(walletImportCmd)
+    .addCommand(walletInspectCmd);

package/dist/commander-patch.js

@@ -0,0 +1,64 @@
+import { Command, Option } from "commander";
+import { FromOpts } from "./from-opts.js";
+export const account = new Option("-a, --account <account>", "Name of the keystore");
+export const password = new Option("-p, --password [password]", "Password to decrypt the keystore");
+export const passwordFile = new Option("-P, --password-file <file>", "File containing the keystore password");
+export const privateKey = new Option("-k, --private-key <key>", "Private key to sign the transaction");
+export const foundry = new Option("-f, --foundry", "Use foundry keystores (~/.foundry/keystores)");
+export const universe = new Option("-u, --universe <universe>", "Universe name").default("anvil");
+export const network = new Option("-n, --network <network>", "Network name").default("dev");
+export const json = new Option("-j, --json [file]", "Output result as JSON to stdout or file, implies --quiet");
+export const quiet = new Option("-q, --quiet", "Suppress info messages");
+export const noQuiet = new Option("--no-quiet", "Force info messages even when --json is set");
+export const keystoreOptions = [account, password, passwordFile, foundry];
+export const outputOptions = [json, quiet, noQuiet];
+export const writeOptions = [universe, account, password, passwordFile, foundry];
+Command.prototype.addCommands = function (commands) {
+    commands.forEach((cmd) => this.addCommand(cmd));
+    return this;
+};
+Command.prototype.addArguments = function (arg) {
+    arg.forEach((arg) => this.addArgument(arg));
+    return this;
+};
+Command.prototype.addOptions = function (options) {
+    options.forEach((opt) => this.addOption(opt));
+    return this;
+};
+Command.prototype.addKeystoreOptions = function () {
+    return this.addOptions([account, password, passwordFile, foundry]);
+};
+Command.prototype.addOutputOptions = function () {
+    return this.addOptions([json, quiet, noQuiet]);
+};
+Command.prototype.addWriteOptions = function () {
+    return this.addKeystoreOptions().addOption(universe);
+};
+Command.prototype.subReadAction = function (fn) {
+    // eslint-disable-next-line
+    return this.action(async function (...args) {
+        const api = await FromOpts.getSubstrateApi(this.opts());
+        try {
+            return await fn.call(this, api, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    });
+};
+Command.prototype.subWriteAction = function (fn) {
+    // eslint-disable-next-line
+    async function _action(...args) {
+        const opts = this.opts();
+        const api = await FromOpts.getSubstrateApi(opts);
+        try {
+            const keystore = await FromOpts.getKeystore(opts);
+            const pair = await keystore.pair();
+            return await fn.call(this, api, pair, ...args);
+        }
+        finally {
+            await api.disconnect().catch(() => { });
+        }
+    }
+    return this.action(_action);
+};

package/dist/config.js

@@ -1,61 +1,72 @@
 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 { z } from "zod";
 import { __dirname } from "./utils.js";
-// Cache
-let CONFIG_CACHED = null;
-export function getUniverseConfig(opts) {
-    const config = loadProtocolConfig();
-    const universeName = opts.universe || "local";
-    const universe = config.universes[universeName];
-    if (!universe) {
-        const available = Object.keys(config.universes).join(", ");
-        throw new Error(`Universe "${universeName}" not found. Available: ${available}`);
-    }
-    return universe;
+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);
+}
+export function loadMergedConfig() {
+    const [config] = _loadMergedConfig();
+    return config;
 }
-function loadProtocolConfig() {
-    if (CONFIG_CACHED)
-        return CONFIG_CACHED;
-    const configPaths = new Set([
-        path.resolve(__dirname, "../.every.toml"),
-        path.resolve(os.homedir(), ".every.toml"),
-        path.resolve(process.cwd(), ".every.toml"),
-    ]);
-    const mergedConfig = {
-        universes: {},
-    };
-    for (const configPath of configPaths) {
-        if (!fs.existsSync(configPath))
-            continue;
-        try {
-            const raw = fs.readFileSync(configPath, "utf8");
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const parsed = parseTOML(raw);
-            if (parsed.universes) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                for (const [name, uni] of Object.entries(parsed.universes)) {
-                    // console.log(name, uni);
-                    mergedConfig.universes[name] = {
-                        name: name,
-                        id: uni.id,
-                        rpc: uni.rpc,
-                        explorer: uni.explorer,
-                        observer: uni.observer,
-                        contracts: uni.contracts || {},
-                    };
-                }
+export function _loadMergedConfig() {
+    const search = [
+        ...new Set([
+            path.resolve(__dirname, "../.every.toml"),
+            path.resolve(os.homedir(), ".every.toml"),
+            path.resolve(process.cwd(), ".every.toml"),
+        ]),
+    ];
+    const files = search.filter((f) => fs.existsSync(f));
+    if (files.length === 0) {
+        throw new Error(`No config file found. Searched in:\n  ${search.join("\n  ")}`);
+    }
+    const merged = { universes: {}, observers: {} };
+    for (const file of files) {
+        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
+                };
             }
-            console.log(`Loaded configuration from ${configPath}`);
         }
-        catch (err) {
-            console.warn(`Failed to load ${configPath}:`, err);
+        if (raw.observers) {
+            for (const [name, obs] of Object.entries(raw.observers)) {
+                merged.observers[name] = {
+                    ...(merged.observers[name] ?? {}),
+                    ...obs,
+                };
+            }
         }
     }
-    if (Object.keys(mergedConfig.universes).length === 0) {
-        console.warn("No universe configurations found");
-    }
-    CONFIG_CACHED = mergedConfig;
-    return CONFIG_CACHED;
+    return [ConfigSchema.parse(merged), files];
 }

package/dist/ethereum.js

@@ -0,0 +1,33 @@
+import { parseEventLogs } from "viem";
+import columnify from "columnify";
+import { stringify as j11 } from "json11";
+export async function submitSimulation(simulation, publicClient, walletClient, console) {
+    console.log("Transaction sending...");
+    const { request } = await publicClient.simulateContract(simulation);
+    const hash = await walletClient.writeContract(request);
+    console.log(`Transaction sent: ${hash}`);
+    console.log("Waiting for confirmation...");
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    console.log(`Confirmed in: block ${receipt.blockNumber}, hash ${receipt.blockHash}`);
+    const output = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const events = [];
+    if (receipt.logs && receipt.logs.length > 0) {
+        const parsedLogs = parseEventLogs({ abi: simulation.abi, logs: receipt.logs });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parsedLogs.forEach((log, i) => {
+            output.push([i, log.eventName, j11(log.args)]);
+            events.push({ name: log.eventName, data: log.args });
+        });
+    }
+    if (output.length > 0) {
+        console.log("Events emitted");
+        const termWidth = process.stdout.columns || 80;
+        const config = {
+            2: { maxWidth: Math.max(60, termWidth - 20) },
+        };
+        console.log(columnify(output, { showHeaders: false, truncateMarker: "", config }));
+    }
+    const result = { transaction: hash, block: { number: receipt.blockNumber, hash: receipt.blockHash }, events };
+    console.result(result);
+}

package/dist/from-opts.js

@@ -0,0 +1,161 @@
+import { bytesToHex, createPublicClient, createWalletClient, http } from "viem";
+import fs from "fs";
+import path from "path";
+import { Wallet } from "ethers";
+import { privateKeyToAccount } from "viem/accounts";
+import promptSync from "prompt-sync";
+import os from "os";
+import { loadMergedConfig } from "./config.js";
+import Keyring from "@polkadot/keyring";
+import { UnifiedKeystore } from "./keystore.js";
+import { decodePairFromJson, loadJson } from "./utils.js";
+import { ApiPromise, WsProvider } from "@polkadot/api";
+export const FromOpts = {
+    getKeystoreDir: function (opts) {
+        if (opts.foundry) {
+            return path.join(os.homedir(), ".foundry", "keystores");
+        }
+        if (opts.dir) {
+            return opts.dir;
+        }
+        return path.join(os.homedir(), ".every", "keystores");
+    },
+    getKeystoreFile: function (opts, name) {
+        const dir = FromOpts.getKeystoreDir(opts);
+        return path.join(dir, name);
+    },
+    getKeystore: async function (opts, account) {
+        const name = account ?? opts.account;
+        if (!name) {
+            throw new Error(`account not specified`);
+        }
+        const keyFile = FromOpts.getKeystoreFile(opts, account ?? opts.account);
+        const keyData = loadJson(keyFile);
+        const password = FromOpts.getPassword(opts);
+        const keystore = await UnifiedKeystore.fromJSON(keyData, password);
+        return keystore;
+    },
+    getPassword: function (opts) {
+        return opts.password
+            ? opts.password
+            : opts.passwordFile
+                ? fs.readFileSync(opts.passwordFile, "utf8").trim()
+                : promptSync({ sigint: true })("Enter keystore password: ", { echo: "" });
+    },
+    confirmPassword: function (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("Enter keystore password: ", { echo: "" });
+        const confirmation = prompt("Re-enter to confirm: ", { echo: "" });
+        if (password !== confirmation) {
+            throw new Error(`Error: Passwords do not match`);
+        }
+        return password;
+    },
+    getUniverseConfig: function (opts) {
+        const config = loadMergedConfig();
+        const universeName = opts.universe;
+        const universe = config.universes[universeName];
+        if (!universe) {
+            const available = Object.keys(config.universes).join(", ");
+            throw new Error(`Universe "${universeName}" not found. Available: ${available}`);
+        }
+        return universe;
+    },
+    getObserverConfig: function (options) {
+        const conf = loadMergedConfig();
+        let observerName;
+        const DEFAULT_OBSERVER = "localnet";
+        if (options.network) {
+            observerName = options.network;
+        }
+        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;
+    },
+    getPair: async function (opts) {
+        const keyFile = FromOpts.getKeystoreFile(opts, opts.account);
+        const keyData = loadJson(keyFile);
+        const keyring = new Keyring();
+        const pair = keyring.createFromJson(keyData);
+        if (pair.isLocked) {
+            const password = FromOpts.getPassword(opts);
+            pair.unlock(password);
+        }
+        return pair;
+    },
+    getPrivateKey: async function (opts) {
+        if (opts.privateKey) {
+            return opts.privateKey.startsWith("0x") ? opts.privateKey : `0x${opts.privateKey}`;
+        }
+        else if (opts.account) {
+            const keyFile = FromOpts.getKeystoreFile(opts, opts.account);
+            const keyData = loadJson(keyFile);
+            if (keyData.crypto || keyData.Crypto) {
+                // for Ethereum keystores
+                const password = FromOpts.getPassword(opts);
+                const wallet = await Wallet.fromEncryptedJson(JSON.stringify(keyData), password);
+                return wallet.privateKey;
+            }
+            else if (keyData.encoding || keyData.meta) {
+                // for Substrate keystores, must be ethereum type
+                if (keyData.meta?.isEthereum || keyData.meta?.type === "ethereum") {
+                    const password = FromOpts.getPassword(opts);
+                    const pair = decodePairFromJson(keyData, 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(`Neither account nor private key specified`);
+        }
+    },
+    toWriteEthereum: async function (opts) {
+        const conf = FromOpts.getUniverseConfig(opts);
+        const transport = http(conf.rpc);
+        const publicClient = createPublicClient({ transport });
+        const privateKey = await FromOpts.getPrivateKey(opts);
+        const account = privateKeyToAccount(privateKey);
+        const walletClient = createWalletClient({ account, transport });
+        return { publicClient, walletClient, conf };
+    },
+    toReadEthereum: function (opts) {
+        const conf = FromOpts.getUniverseConfig(opts);
+        const transport = http(conf.rpc);
+        const publicClient = createPublicClient({ transport });
+        return { publicClient, conf };
+    },
+    getSubstrateApi: async function (opts) {
+        const conf = FromOpts.getObserverConfig(opts);
+        const provider = new WsProvider(conf.rpc);
+        const api = await ApiPromise.create({ provider, noInitWarn: true });
+        return api;
+    },
+};

package/dist/index.js

@@ -3,6 +3,7 @@ import { program } from "./program.js";
 try {
     await program.parseAsync();
 }
-catch (e) {
+catch (e /* eslint-disable-line */) {
     console.error(e.message);
+    process.exitCode = 1;
 }

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;
+    }
+}