@everyprotocol/every-cli 0.1.2 → 0.1.3

package/dist/abi.js

@@ -31,6 +31,11 @@ export const abi = {
             "function mint(address to, address set, uint64 id, bytes memory data, bytes memory auth, uint32 policy) payable",
         ]),
         ...loadNonFuncAbiItems("ObjectMinter"),
+        ...loadNonFuncAbiItems("ISet"),
+    ],
+    create: [
+        ...parseAbi(["function create(address to, uint64 id0, bytes calldata data) payable"]),
+        ...loadNonFuncAbiItems("ISet"),
     ],
     relation: [
         ...parseAbi([

package/dist/config.js

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

package/dist/keystore.js

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

package/dist/matter.js

@@ -3,51 +3,10 @@ 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;
-}
+import { getObserverConfig, keystoreFromOptions } from "./utils.js";
+import "./options.js";
+import { findEvent, submitTransaction } from "./substrate.js";
+import JSON5 from "json5";
 function guessContentType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
@@ -67,61 +26,43 @@ function guessContentType(filePath) {
     }
 }
 export function genMatterCommand() {
-    const cmd = new Command().name("matter").description("Manage matters");
+    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")
+        .option("-u, --universe <name>", "Universe name")
+        .option("-o, --observer <name>", "Observer name")
+        .accountOptions()
         .action(async (files, options) => {
         const materials = [];
         // Process each file argument
         for (const file of files) {
-            let [filePath, hasher_, contentType] = file.split(":");
+            const [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);
-                }
-            }
+            const contentType = contentType_ || options.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);
+        const conf = getObserverConfig(options);
+        const keystore = await keystoreFromOptions(options);
+        const pair = await keystore.pair();
         // Connect to the Substrate node
-        console.log(`Connecting to ${conf.observer.rpc}...`);
-        const provider = new WsProvider(conf.observer.rpc);
+        // console.log(`Connecting to ${conf.rpc}...`);
+        const provider = new WsProvider(conf.rpc);
         const api = await ApiPromise.create({ provider });
         await api.isReady;
-        console.log("Connected to Substrate node");
+        // 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);
+            const call = api.tx.every.matterRegister(hasher, contentType, contentRaw);
             console.log(`Submitting transaction for ${filePath}...`);
-            const txn = await submitTransaction(api, call, accountPair);
+            const txn = await submitTransaction(api, call, pair);
             console.log(`Transaction submitted: ${txn.txHash}`);
             txns.push({ txn, filePath });
         }
@@ -134,15 +75,18 @@ export function genMatterCommand() {
                 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.gateway) {
+                    console.log(`  Preimage: ${conf.gateway}/m/${hash}`);
                 }
-                if (conf.observer.explorer) {
-                    console.log(`  Transaction: ${conf.observer.explorer}/extrinsic/${receipt.blockNumber}-${receipt.txIndex}`);
+                if (conf.explorer) {
+                    // console.log(`  Transaction: ${conf.explorer}/extrinsic/${receipt.blockNumber}-${receipt.txIndex}`);
                 }
             }
             else {
                 console.log(`${filePath} finalized, but no MaterialAdded event found`);
+                for (const { event } of receipt.events) {
+                    console.log(`${event.method.padEnd(20)}`, JSON5.stringify(event.data.toHuman()));
+                }
             }
         }
         await api.disconnect();

package/dist/mint.js

@@ -7,13 +7,14 @@ import { abi } from "./abi.js";
 export function genMintCommand() {
     const cmd = new Command()
         .name("mint")
-        .description("Mint an object via ObjectMinter")
-        .option("--auth <data>", "authorization data, if needed for a permissioned mint", "0x")
-        .option("--policy <index>", "the index number of the mint policy", "0")
+        .description("Mint an object via the object minter or directly from the set")
+        .option("--to <address>", "specify the recipient")
         .option("--value <amount>", "the amount of ETH to send together", "0")
+        .option("--auth <data>", "authorization data for a permissioned mint", "0x")
+        .option("--policy <index>", "the index number of the mint policy", "0")
+        .option("--no-minter", "mint directly from set contract instead of using ObjectMinter")
         .argument("<sid>", "scoped object ID, in form of set.id (e.g., 17.1)")
-        .argument("<to>", "address of the recipient")
-        .argument("[data]", "additional mint data", "0x")
+        .argument("[data]", "additional input data", "0x")
         .action(action);
     defaultWriteFunctionOptions().forEach((option) => cmd.addOption(option));
     return cmd;
@@ -22,7 +23,6 @@ async function action() {
     const opts = this.opts();
     const args0 = this.args;
     const conf = getUniverseConfig(opts);
-    const objectMinter = conf.contracts["ObjectMinter"];
     const setRegistry = conf.contracts["SetRegistry"];
     const { publicClient, walletClient } = await getClientsEth(conf, opts);
     const account = walletClient.account;
@@ -34,28 +34,42 @@ async function action() {
         args: [BigInt(set)],
     }));
     const value = parseUnits(opts.value || "0", 18);
-    const { request } = await publicClient.simulateContract({
-        address: objectMinter,
-        abi: abi.mint,
-        functionName: "mint",
-        args: [
-            args0[1],
-            setContract,
-            BigInt(id),
-            (args0[2] || "0x"),
-            opts.auth || "0x",
-            Number(opts.policy || "0"),
-        ],
-        account,
-        value,
-    });
-    const hash = await walletClient.writeContract(request);
+    // Use the provided recipient address or default to the sender's address
+    const recipientAddress = (opts.to || account.address);
+    const mintData = (args0[1] || "0x");
+    let hash;
+    if (opts.minter) {
+        // Mint via ObjectMinter
+        const objectMinter = conf.contracts["ObjectMinter"];
+        const { request } = await publicClient.simulateContract({
+            address: objectMinter,
+            abi: abi.mint,
+            functionName: "mint",
+            args: [recipientAddress, setContract, BigInt(id), mintData, opts.auth || "0x", Number(opts.policy || "0")],
+            account,
+            value,
+        });
+        hash = await walletClient.writeContract(request);
+    }
+    else {
+        // Mint directly from set contract
+        const { request } = await publicClient.simulateContract({
+            address: setContract,
+            abi: abi.create,
+            functionName: "create",
+            args: [recipientAddress, BigInt(id), mintData],
+            account,
+            value,
+        });
+        hash = await walletClient.writeContract(request);
+    }
     console.log(`Transaction sent: ${hash}`);
     console.log("Transaction mining...");
     const receipt = await publicClient.waitForTransactionReceipt({ hash });
     console.log("Transaction mined");
     if (receipt.logs && receipt.logs.length > 0) {
-        const parsedLogs = parseEventLogs({ abi: abi.mint, logs: receipt.logs });
+        const abiToUse = opts.minter ? abi.mint : abi.create;
+        const parsedLogs = parseEventLogs({ abi: abiToUse, logs: receipt.logs });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         parsedLogs.forEach((log) => {
             console.log(" - Event", log.eventName, stringify(log.args));

package/dist/options.js

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

package/dist/program.js

@@ -2,7 +2,7 @@ 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 { walletCmd } from "./wallet.js";
 import { genMatterCommand } from "./matter.js";
 function buildProgram() {
     const subCmds = generateCommands();
@@ -19,7 +19,7 @@ function buildProgram() {
         .description("create and interact with objects")
         .addCommands(subCmds.object);
     const mintPolicyCmd = new RenamingCommand()
-        .name("mintpolicy")
+        .name("minter")
         .description("manage mint policies")
         .addCommands(subCmds.mintpolicy);
     const program = new Command()
@@ -27,15 +27,15 @@ function buildProgram() {
         .description("CLI for interacting with Every Protocol")
         .version(version())
         .showHelpAfterError(true);
-    program.addCommand(kindCmd);
+    program.addCommand(genMatterCommand());
     program.addCommand(setCmd);
+    program.addCommand(kindCmd);
     program.addCommand(relationCmd);
-    program.addCommand(uniqueCmd);
     program.addCommand(valueCmd);
+    program.addCommand(uniqueCmd);
     program.addCommand(objectCmd);
     program.addCommand(mintPolicyCmd);
-    program.addCommand(genWalletCommands());
-    program.addCommand(genMatterCommand());
+    program.addCommand(walletCmd);
     return program;
 }
 export const program = buildProgram();

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

@@ -11,7 +11,9 @@ 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");
@@ -179,3 +181,42 @@ export function getSubstrateAccountPair(flags) {
     }
     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;
+}