@xyo-network/xl1-cli 1.6.4 → 1.6.6

package/build/node/xl1.mjs

@@ -4,7 +4,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/initEnv.ts
 import dotenv from "dotenv";
 var initEnv = /* @__PURE__ */ __name(() => {
-  dotenv.config();
+  dotenv.config({
+    quiet: true
+  });
   if (process.env.ENV_FILE !== void 0) {
     dotenv.config({
       path: process.env.ENV_FILE,
@@ -13,17 +15,32 @@ var initEnv = /* @__PURE__ */ __name(() => {
   }
 }, "initEnv");
 
+// src/initLogger.ts
+import { Base } from "@xylabs/base";
+import { ConsoleLogger, LogLevel } from "@xylabs/logger";
+import { isDefined } from "@xylabs/typeof";
+var initLogger = /* @__PURE__ */ __name(() => {
+  let level = LogLevel.info;
+  if (isDefined(process.env.LOG_LEVEL)) {
+    const parsed = LogLevel[process.env.LOG_LEVEL.toLowerCase()];
+    if (isDefined(parsed)) level = parsed;
+  }
+  const logger = new ConsoleLogger(level);
+  Base.defaultLogger = logger;
+  return logger;
+}, "initLogger");
+
 // src/orchestration/actor/implementation/BalanceActor.ts
 import { assertEx } from "@xylabs/assert";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { Mutex } from "async-mutex";
 
 // src/orchestration/actor/model/Actor.ts
-import { BaseEmitter } from "@xylabs/events";
+import { Base as Base2 } from "@xylabs/base";
 import { forget } from "@xylabs/forget";
 import { IdLogger } from "@xylabs/logger";
 import { span, spanAsync } from "@xylabs/telemetry";
-var Actor = class extends BaseEmitter {
+var Actor = class extends Base2 {
   static {
     __name(this, "Actor");
   }
@@ -32,7 +49,7 @@ var Actor = class extends BaseEmitter {
   _displayName;
   _id;
   constructor(id, displayName = "Actor", params) {
-    const logger = params.logger ?? new IdLogger(console, () => `[${displayName} (${id})] `);
+    const logger = params.logger ?? new IdLogger(Base2.defaultLogger ?? console, () => `[${displayName} (${id})] `);
     super({
       ...params,
       logger
@@ -114,7 +131,11 @@ var Orchestrator = class {
   }
   actors = [];
   keepAliveHandle = null;
+  logger;
   running = false;
+  constructor(logger) {
+    this.logger = logger;
+  }
   /**
   * Registers an actor.
   * (We won't activate the actor until `start()` is called.)
@@ -131,10 +152,10 @@ var Orchestrator = class {
   async start() {
     await Promise.resolve();
     if (this.running) {
-      console.log("[Orchestrator] Already started.");
+      this.logger?.warn("[Orchestrator] Already started.");
       return;
     }
-    console.log("[Orchestrator] Starting...");
+    this.logger?.log("[Orchestrator] Starting...");
     this.running = true;
     for (const actor of this.actors) {
       await actor.start();
@@ -148,16 +169,16 @@ var Orchestrator = class {
   async stop() {
     await Promise.resolve();
     if (!this.running) {
-      console.log("[Orchestrator] Already stopped.");
+      this.logger?.log("[Orchestrator] Already stopped.");
       return;
     }
-    console.log("[Orchestrator] Stopping...");
+    this.logger?.log("[Orchestrator] Stopping...");
     for (const actor of this.actors) {
       await actor.stop();
     }
     this.running = false;
     if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
-    console.log("[Orchestrator] Stopped...");
+    this.logger?.log("[Orchestrator] Stopped...");
   }
 };
 
@@ -216,8 +237,7 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
   get chainIterator() {
     return assertEx2(this.params.chainIterator, () => "chainIterator not set");
   }
-  static async create(params) {
-    await Promise.resolve();
+  static create(params) {
     return new _ChainHeadUpdateActor(params);
   }
   async start() {
@@ -252,7 +272,7 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
 // src/orchestration/actor/implementation/ProducerActor.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
-import { isDefined, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
 import { createDeclarationIntent } from "@xyo-network/chain-protocol";
 import { BaseBlockProducerService } from "@xyo-network/chain-services";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
@@ -267,7 +287,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   _lastProducedBlock;
   _lastRedeclarationIntent;
   constructor(params) {
-    super(assertEx3(params.producer?.address, () => "Missing producer in params"), "Producer", params);
+    super(params.producer.address, "Producer", params);
   }
   get account() {
     return assertEx3(this.params.account, () => "account not set");
@@ -293,8 +313,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   get stakeIntentService() {
     return assertEx3(this.params.stakeIntentService, () => "stakeIntentService not set");
   }
-  static async create(params) {
-    await Promise.resolve();
+  static create(params) {
     return new _ProducerActor(params);
   }
   async start() {
@@ -379,7 +398,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   async validateCurrentBalance() {
     const head = this._lastProducedBlock?.[0]._hash;
-    if (isDefined(head)) {
+    if (isDefined2(head)) {
       const balances = await this.balanceService.balances(head, [
         this.account.address
       ]);
@@ -393,7 +412,7 @@ var ProducerActor = class _ProducerActor extends Actor {
     return true;
   }
   async validateCurrentStake() {
-    const requiredMinimumStake = isDefined(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
+    const requiredMinimumStake = isDefined2(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
     const currentStake = await this.chainStakeViewer.activeByAddressStaked(this.account.address);
     if (currentStake < requiredMinimumStake) {
       this.logger?.error(`Producer ${this.account.address} has insufficient stake.`);
@@ -405,7 +424,7 @@ var ProducerActor = class _ProducerActor extends Actor {
 
 // src/orchestration/health/initHealthEndpoints.ts
 import http from "http";
-import { isDefined as isDefined2, isEmptyString } from "@xylabs/typeof";
+import { isDefined as isDefined3, isEmptyString } from "@xylabs/typeof";
 var sendStatus = /* @__PURE__ */ __name((res, status, errorCode) => {
   const statusCode = status === "started" ? 200 : errorCode;
   res.writeHead(statusCode, {
@@ -455,7 +474,7 @@ var createHealthServer = /* @__PURE__ */ __name((port = 8080, statusMonitor) =>
 }, "createHealthServer");
 var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
   const healthCheckEnvVarPort = process.env.XYO_PRODUCER_HEALTH_CHECK_PORT;
-  if (isDefined2(healthCheckEnvVarPort) && !isEmptyString(healthCheckEnvVarPort)) {
+  if (isDefined3(healthCheckEnvVarPort) && !isEmptyString(healthCheckEnvVarPort)) {
     const healthCheckPort = Number.parseInt(healthCheckEnvVarPort, 10);
     return createHealthServer(healthCheckPort, params.statusReporter);
   }
@@ -463,9 +482,8 @@ var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
 
 // src/orchestration/initServices.ts
 import { assertEx as assertEx16 } from "@xylabs/assert";
-import { Base } from "@xylabs/base";
 import { asAddress as asAddress2 } from "@xylabs/hex";
-import { isDefined as isDefined5 } from "@xylabs/typeof";
+import { isDefined as isDefined6 } from "@xylabs/typeof";
 import { balanceSummaryRepositoryFromMap } from "@xyo-network/chain-modules";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
@@ -708,9 +726,7 @@ var singleton11;
 var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex11.runExclusive(async () => {
     if (singleton11) return singleton11;
-    console.log("[InitServices:LocalStakeIntentStateArchivist:Initializing]");
     singleton11 = await getLocalPersistentArchivist("stakeIntent", "state");
-    console.log("[InitServices:LocalStakeIntentStateArchivist:Initialized]");
     return assertEx8(singleton11, () => new Error("Failed to initialize stake intent state archivist"));
   });
 }, "initLocalStakeIntentStateArchivist");
@@ -728,12 +744,12 @@ var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async () => {
 }, "initStakeIntentStateArchivist");
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
-import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
 import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
 import { Mutex as Mutex15 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/local.ts
-import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { isDefined as isDefined4 } from "@xylabs/typeof";
 import { Mutex as Mutex14 } from "async-mutex";
 
 // src/orchestration/map/localPersistentMap.ts
@@ -821,7 +837,7 @@ var mutex13 = new Mutex14();
 var singleton13;
 var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async () => {
   return await mutex13.runExclusive(async () => {
-    if (isDefined3(singleton13)) return singleton13;
+    if (isDefined4(singleton13)) return singleton13;
     singleton13 = await getLocalPersistentMap("balance", "summary");
     return singleton13;
   });
@@ -832,7 +848,7 @@ var mutex14 = new Mutex15();
 var singleton14;
 async function initBalanceSummaryMap(_traceProvider) {
   return await mutex14.runExclusive(async () => {
-    if (isDefined4(singleton14)) return singleton14;
+    if (isDefined5(singleton14)) return singleton14;
     const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap());
     singleton14 = local;
     return singleton14;
@@ -907,8 +923,8 @@ var getChainId = /* @__PURE__ */ __name(() => {
 
 // src/orchestration/services/implementation/evm/initGanacheProvider.ts
 var initJsonRpcProvider = /* @__PURE__ */ __name(() => {
-  const config2 = getJsonRpcProviderConfig();
-  return Promise.resolve(new JsonRpcProvider(...config2));
+  const config = getJsonRpcProviderConfig();
+  return Promise.resolve(new JsonRpcProvider(...config));
 }, "initJsonRpcProvider");
 var canUseJsonRpcProvider = /* @__PURE__ */ __name(() => {
   return canUseChainId() && process.env.XYO_JSON_RPC_URL !== void 0;
@@ -927,8 +943,8 @@ import { InfuraProvider } from "ethers/providers";
 var instance;
 var initInfuraProvider = /* @__PURE__ */ __name(() => {
   if (instance) return instance;
-  const config2 = getInfuraProviderConfig();
-  instance = Promise.resolve(new InfuraProvider(...config2));
+  const config = getInfuraProviderConfig();
+  instance = Promise.resolve(new InfuraProvider(...config));
   return instance;
 }, "initInfuraProvider");
 var canUseInfuraProvider = /* @__PURE__ */ __name(() => {
@@ -1197,20 +1213,19 @@ var telemetryConfig = {
   }
 };
 var isStartable = /* @__PURE__ */ __name((value) => {
-  return isDefined5(value.start) && typeof value.start === "function";
+  return isDefined6(value.start) && typeof value.start === "function";
 }, "isStartable");
 var initServices = /* @__PURE__ */ __name(async (logger) => {
-  Base.defaultLogger = logger ?? console;
-  const statusReporter = new RuntimeStatusMonitor(logger ?? console);
+  const statusReporter = new RuntimeStatusMonitor(logger);
   statusReporter.onGlobalTransition({
     to: "started"
   }, () => {
-    Base.defaultLogger?.log("All services started.");
+    logger.log("All services started.");
   });
   statusReporter.onGlobalTransition({
     to: "error"
   }, () => {
-    Base.defaultLogger?.error("Producer encountered an unhandled error!");
+    logger.error("Producer encountered an unhandled error!");
     process.exit(1);
   });
   await startupSpanAsync7("initHealthEndpoints", () => initHealthEndpoints({
@@ -1277,7 +1292,6 @@ var initServices = /* @__PURE__ */ __name(async (logger) => {
     chainArchivist,
     chainIterator,
     chainStakeViewer,
-    logger: console,
     stakeIntentStateArchivist,
     traceProvider,
     statusReporter
@@ -1302,7 +1316,7 @@ var initServices = /* @__PURE__ */ __name(async (logger) => {
     traceProvider,
     validateHydratedBlockState
   };
-  const rewardAddress = isDefined5(process.env.XYO_BLOCK_REWARD_ADDRESS) ? assertEx16(asAddress2(process.env.XYO_BLOCK_REWARD_ADDRESS), () => "Invalid block reward address provided") : account.address;
+  const rewardAddress = isDefined6(process.env.XYO_BLOCK_REWARD_ADDRESS) ? assertEx16(asAddress2(process.env.XYO_BLOCK_REWARD_ADDRESS), () => "Invalid block reward address provided") : account.address;
   const producerParams = {
     ...validatorParams,
     name: "Producer",
@@ -1330,7 +1344,7 @@ var initServices = /* @__PURE__ */ __name(async (logger) => {
     rewardService,
     stakeIntentService
   };
-  Base.defaultLogger?.log("All services created. Starting...");
+  logger?.log("All services created. Starting...");
   const startableServices = [
     balanceSummaryMap,
     ...Object.values(result)
@@ -1346,18 +1360,18 @@ import { hideBin } from "yargs/helpers";
 
 // src/commands/api/runApi.ts
 import { getServer } from "@xyo-network/chain-api";
-import { config } from "dotenv";
-function runApi() {
-  config();
-  void getServer();
+function runApi(context) {
+  const { logger } = context;
+  void getServer(void 0, void 0, logger);
 }
 __name(runApi, "runApi");
 
 // src/commands/producer/runProducer.ts
-var runProducer = /* @__PURE__ */ __name(async (orchestrator) => {
-  console.log("Services: Initializing...");
-  const services = await initServices();
-  console.log("Services: Initialized");
+var runProducer = /* @__PURE__ */ __name(async (context) => {
+  const { logger, orchestrator } = context;
+  logger?.log("Services: Initializing...");
+  const services = await initServices(logger);
+  logger?.log("Services: Initialized");
   const chainHeadUpdate = await ChainHeadUpdateActor.create(services);
   const producer = await ProducerActor.create(services);
   const balances = await BalanceActor.create(services);
@@ -1373,7 +1387,8 @@ var runProducer = /* @__PURE__ */ __name(async (orchestrator) => {
 }, "runProducer");
 
 // src/commands/validator/runValidator.ts
-var runValidator = /* @__PURE__ */ __name(async (orchestrator) => {
+var runValidator = /* @__PURE__ */ __name(async (context) => {
+  const { orchestrator } = context;
   const myActor = new Actor("Validator", "Validator", {});
   await orchestrator.registerActor(myActor);
   await orchestrator.start();
@@ -1399,28 +1414,25 @@ function waitForPort(host, port) {
   });
 }
 __name(waitForPort, "waitForPort");
-async function runCLI(orchestrator) {
+async function runCLI(context) {
   async function validateTransaction() {
-    console.log("Validating transaction...");
-    await Promise.resolve();
+    await Promise.reject("Not implemented yet");
   }
   __name(validateTransaction, "validateTransaction");
   async function submitTransaction() {
-    console.log("Submitting transaction...");
-    await Promise.resolve();
+    await Promise.reject("Not implemented yet");
   }
   __name(submitTransaction, "submitTransaction");
   async function checkBalance() {
-    console.log("Checking account balance...");
-    await Promise.resolve();
+    await Promise.reject("Not implemented yet");
   }
   __name(checkBalance, "checkBalance");
   const argv = yargs(hideBin(process.argv)).command("validator", "Run the XL1 validator", (yargs2) => {
     return yargs2.command("$0", "Run as a XL1 validator node", () => {
-    }, () => runValidator(orchestrator));
+    }, () => runValidator(context));
   }).command("producer", "Run the XL1 producer", (yargs2) => {
     return yargs2.command("$0", "Run as a XL1 producer node", () => {
-    }, () => runProducer(orchestrator));
+    }, () => runProducer(context));
   }).command("client", "Client-related operations", (yargs2) => {
     return yargs2.command("transaction", "Transaction-related operations", (yargs3) => {
       return yargs3.command("validate", "Validate a transaction", () => {
@@ -1429,14 +1441,14 @@ async function runCLI(orchestrator) {
     });
   }).command("api", "Run as a api node", (yargs2) => {
     return yargs2.command("$0", "Run as a api node", () => {
-    }, () => runApi()).command("run", "Run as a api node", () => {
-    }, () => runApi());
+    }, () => runApi(context)).command("run", "Run as a api node", () => {
+    }, () => runApi(context));
   }).command("$0", "Run a full XL1 deployment", (yargs2) => {
     return yargs2.command("$0", "Start the API and a producer", () => {
     }, async () => {
-      runApi();
+      runApi(context);
       await waitForPort("localhost", 8080);
-      await runProducer(orchestrator);
+      await runProducer(context);
     });
   }).command("account", "Account-related operations", (yargs2) => {
     return yargs2.command("balance", "Check account balance", () => {
@@ -1449,21 +1461,25 @@ __name(runCLI, "runCLI");
 // src/start.ts
 var start = /* @__PURE__ */ __name(async () => {
   initEnv();
-  const orchestrator = new Orchestrator();
+  const logger = initLogger();
+  const orchestrator = new Orchestrator(logger);
   process.on("SIGINT", () => {
     void (async () => {
       try {
-        console.log("\nSIGINT received. Attempting graceful shutdown...");
+        logger.log("\nSIGINT received. Attempting graceful shutdown...");
         await orchestrator?.stop();
-        console.log("Orchestrator stopped, exiting now.");
+        logger.log("Orchestrator stopped, exiting now.");
         process.exit(0);
       } catch (err) {
-        console.error("Error stopping orchestrator:", err);
+        logger.error("Error stopping orchestrator:", err);
         process.exit(1);
       }
     })();
   });
-  await runCLI(orchestrator);
+  await runCLI({
+    logger,
+    orchestrator
+  });
 }, "start");
 
 // src/xl1.ts