@xyo-network/xl1-cli-lib 1.14.2 → 1.14.3

package/dist/node/index.mjs

@@ -9,7 +9,7 @@ import { Mutex } from "async-mutex";
 // src/orchestration/actor/model/Actor.ts
 import { Base } from "@xylabs/base";
 import { IdLogger } from "@xylabs/logger";
-import { span, spanAsync } from "@xylabs/telemetry";
+import { span, spanRootAsync } from "@xylabs/telemetry";
 var Actor = class extends Base {
   static {
     __name(this, "Actor");
@@ -68,7 +68,7 @@ var Actor = class extends Base {
     return span(`${this.name}:${name}`, fn, this.tracer);
   }
   async spanAsync(name, fn) {
-    return await spanAsync(`${this.name}:${name}`, fn, this.tracer);
+    return await spanRootAsync(`${this.name}:${name}`, fn, this.tracer);
   }
   /**
   * Called by the Orchestrator when the actor is activated.
@@ -236,9 +236,9 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
     const candidateBlockNumberDisplay = `0x${toHex(candidateBlockNumber)}`;
     const currentBlockNumber = currentHead?.block ?? -1;
     if (candidateBlockNumber > currentBlockNumber) {
-      this.logger?.log("Found more recent head:", candidateBlockNumberDisplay);
+      this.logger?.log("Found more recent head:", candidateBlockNumber, candidateBlockNumberDisplay);
       await this.chainIterator.updateHead(candidateBlock);
-      this.logger?.log("Updated head:", candidateBlockNumberDisplay);
+      this.logger?.log("Updated head:", candidateBlockNumber, candidateBlockNumberDisplay);
     }
   }
 };
@@ -527,9 +527,9 @@ var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
 }, "initHealthEndpoints");
 
 // src/orchestration/initServices.ts
-import { assertEx as assertEx17 } from "@xylabs/assert";
+import { assertEx as assertEx18 } from "@xylabs/assert";
 import { asAddress as asAddress2 } from "@xylabs/hex";
-import { isDefined as isDefined11 } from "@xylabs/typeof";
+import { isDefined as isDefined12 } from "@xylabs/typeof";
 import { balanceSummaryRepositoryFromMap, BaseTimeSyncService, initTelemetry, startupSpanAsync as startupSpanAsync7, validateHydratedBlockState } from "@xyo-network/chain-sdk";
 
 // src/orchestration/archivists/ChainFinalized/archivist.ts
@@ -552,13 +552,14 @@ var getStoreDirectory = /* @__PURE__ */ __name((name, storageRoot, kind) => {
 
 // src/orchestration/archivists/lib/localPersistentArchivist.ts
 var DEFAULT_STORAGE_ROOT = Path2.join(process.cwd(), ".store");
-var getLocalPersistentArchivist = /* @__PURE__ */ __name((dbName, storeName, storageRoot, kind = "lmdb") => {
+var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeName, storageRoot, kind = "lmdb") => {
   switch (kind) {
     case "lmdb": {
       const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
       return LmdbArchivist.create({
         account: "random",
         config: {
+          name,
           clearStoreOnStart: false,
           dbName,
           location: getStoreDirectory(dbName, root, "lmdb"),
@@ -577,7 +578,7 @@ var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: c
   return await mutex.runExclusive(async () => {
     if (singleton) return singleton;
     const { root } = config3.storage;
-    singleton = await getLocalPersistentArchivist("chain", "finalized", root);
+    singleton = await getLocalPersistentArchivist("local-finalized-chain", "chain", "finalized", root);
     return singleton;
   });
 }, "initLocalChainFinalizedArchivist");
@@ -782,7 +783,7 @@ var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config:
   return await mutex11.runExclusive(async () => {
     if (singleton11) return singleton11;
     const { root } = config3.storage;
-    singleton11 = await getLocalPersistentArchivist("stakeIntent", "state", root);
+    singleton11 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
     return assertEx9(singleton11, () => new Error("Failed to initialize stake intent state archivist"));
   });
 }, "initLocalStakeIntentStateArchivist");
@@ -1089,30 +1090,136 @@ var init = /* @__PURE__ */ __name((params) => {
   return chainStakeServiceSingleton2;
 }, "init");
 
-// src/orchestration/services/implementation/head.ts
-import { delay } from "@xylabs/delay";
-import { asHash, hexFromBigInt, ZERO_ADDRESS as ZERO_ADDRESS2 } from "@xylabs/hex";
-import { isDefined as isDefined10 } from "@xylabs/typeof";
-import { buildBlock, createGenesisBlock, findMostRecentBlock as findMostRecentBlock2, isBlockBoundWitnessWithHashStorageMeta } from "@xyo-network/chain-sdk";
-import { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
-var headSingleton;
-var createBootstrapHead = /* @__PURE__ */ __name(async (chainSubmissionsArchivistWrite, chainArchivist, account) => {
-  const block = await createGenesisBlock(account, ZERO_ADDRESS2, 10000000n, account.address);
-  const [bw] = block;
-  await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock2(block));
-  while (true) {
-    const result = await chainArchivist.get([
-      bw._hash
-    ]);
-    if (result.length > 0) break;
-    await delay(1e3);
-  }
-  return bw;
+// src/orchestration/services/implementation/head/head.ts
+import { assertEx as assertEx16 } from "@xylabs/assert";
+import { isDefined as isDefined11 } from "@xylabs/typeof";
+import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-sdk";
+
+// src/orchestration/services/implementation/head/createBootstrapHead.ts
+import { ZERO_ADDRESS as ZERO_ADDRESS2 } from "@xylabs/hex";
+import { createGenesisBlock } from "@xyo-network/chain-sdk";
+var createBootstrapHead = /* @__PURE__ */ __name(async (account) => {
+  return await createGenesisBlock(account, ZERO_ADDRESS2, 10000000n, account.address);
 }, "createBootstrapHead");
-var createForkedHead = /* @__PURE__ */ __name(async (chainSubmissionsArchivistWrite, chainArchivist, account, forkBlock, chainId) => {
+
+// src/orchestration/services/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
+import { BridgeDestinationObservationSchema, buildNextBlock } from "@xyo-network/chain-sdk";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+
+// src/orchestration/services/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
+import { toHex as toHex5 } from "@xylabs/hex";
+
+// src/orchestration/services/implementation/head/createForkedHead/config/getForkDetails.ts
+import { toHex as toHex4 } from "@xylabs/hex";
+import { AttoXL1ConvertFactor } from "@xyo-network/xl1-protocol";
+var getForkBlockReward = /* @__PURE__ */ __name(() => {
+  return 18000000000n * AttoXL1ConvertFactor.xl1;
+}, "getForkBlockReward");
+var getForkBlockRewardHex = /* @__PURE__ */ __name(() => {
+  return toHex4(getForkBlockReward());
+}, "getForkBlockRewardHex");
+
+// src/orchestration/services/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
+var ethChainId = toHex5("0x1");
+var bridgeableTokenContract = toHex5("0x7789e11BB83b398A8Cca8E8D582B33F91499D6f5");
+var bridgeDestAddress = toHex5("0xe53218d47913b5f9E58bb74F0a0eD790bbF21972");
+var destConfirmation = toHex5("0x772ee028f9ad291ec692912c1a33ecd4409e71383fe06f6ebf39f7cdbb779069");
+var getBridgeDestChainId = /* @__PURE__ */ __name(() => ethChainId, "getBridgeDestChainId");
+var getBridgeDestToken = /* @__PURE__ */ __name(() => bridgeableTokenContract, "getBridgeDestToken");
+var getBridgeDestAddress = /* @__PURE__ */ __name(() => bridgeDestAddress, "getBridgeDestAddress");
+var getBridgeDestAmount = /* @__PURE__ */ __name(() => getForkBlockRewardHex(), "getBridgeDestAmount");
+var getBridgeDestConfirmation = /* @__PURE__ */ __name(() => destConfirmation, "getBridgeDestConfirmation");
+var getBridgeDestinationDetails = /* @__PURE__ */ __name(() => {
+  return {
+    dest: getBridgeDestChainId(),
+    destToken: getBridgeDestToken(),
+    destAddress: getBridgeDestAddress(),
+    destAmount: getBridgeDestAmount()
+  };
+}, "getBridgeDestinationDetails");
+
+// src/orchestration/services/implementation/head/createForkedHead/config/getBridgeSourceDetails.ts
+var getBridgeSrcChainId = /* @__PURE__ */ __name((chainService) => chainService.chainId, "getBridgeSrcChainId");
+var getBridgeSrcAddress = /* @__PURE__ */ __name((account) => account.address, "getBridgeSrcAddress");
+var getBridgeSrcToken = /* @__PURE__ */ __name((chainService) => chainService.chainId, "getBridgeSrcToken");
+var getBridgeSrcAmount = /* @__PURE__ */ __name(() => getForkBlockRewardHex(), "getBridgeSrcAmount");
+var getBridgeSourceDetails = /* @__PURE__ */ __name((account, chainService) => {
+  return {
+    src: getBridgeSrcChainId(chainService),
+    srcAddress: getBridgeSrcAddress(account),
+    srcToken: getBridgeSrcToken(chainService),
+    srcAmount: getBridgeSrcAmount()
+  };
+}, "getBridgeSourceDetails");
+
+// src/orchestration/services/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
+var getBridgeDestinationObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const bridgeDestinationObservationFields = {
+    ...getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    destConfirmation: getBridgeDestConfirmation()
+  };
+  const bridgeDestinationObservation = new PayloadBuilder4({
+    schema: BridgeDestinationObservationSchema
+  }).fields(bridgeDestinationObservationFields).build();
+  return await buildNextBlock(previousBlock[0], [], [
+    bridgeDestinationObservation
+  ], [
+    account
+  ]);
+}, "getBridgeDestinationObservation");
+
+// src/orchestration/services/implementation/head/createForkedHead/getBridgeIntent.ts
+import { BridgeIntentSchema, buildNextBlock as buildNextBlock2, createTransferPayload, XYO_BRIDGE_ADDRESS } from "@xyo-network/chain-sdk";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+var getBridgeIntent = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const transferPayload = createTransferPayload(account.address, {
+    [XYO_BRIDGE_ADDRESS]: getForkBlockReward()
+  });
+  const nonce = `${Date.now()}`;
+  const bridgeIntentFields = {
+    ...getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    nonce
+  };
+  const bridgeIntent = new PayloadBuilder5({
+    schema: BridgeIntentSchema
+  }).fields(bridgeIntentFields).build();
+  return await buildNextBlock2(previousBlock[0], [], [
+    bridgeIntent,
+    transferPayload
+  ], [
+    account
+  ]);
+}, "getBridgeIntent");
+
+// src/orchestration/services/implementation/head/createForkedHead/getBridgeSourceObservation.ts
+import { BridgeSourceObservationSchema, buildNextBlock as buildNextBlock3 } from "@xyo-network/chain-sdk";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+var getBridgeSourceObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
+  const srcTxHash = previousBlock[0]._hash;
+  const bridgeSourceObservationFields = {
+    ...getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    // Observation
+    srcConfirmation: srcTxHash
+  };
+  const bridgeSourceObservation = new PayloadBuilder6({
+    schema: BridgeSourceObservationSchema
+  }).fields(bridgeSourceObservationFields).build();
+  return await buildNextBlock3(previousBlock[0], [], [
+    bridgeSourceObservation
+  ], [
+    account
+  ]);
+}, "getBridgeSourceObservation");
+
+// src/orchestration/services/implementation/head/createForkedHead/getFirstBlockForNewChain.ts
+import { buildBlock } from "@xyo-network/chain-sdk";
+var getFirstBlockForNewChain = /* @__PURE__ */ __name(async (forkBlock, account, chainService) => {
   const { _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes, protocol } = forkBlock;
-  const forkBlockReward = 0n;
-  const forkBlockRewardAddress = account.address;
+  const chainId = chainService.chainId;
+  const forkBlockReward = getForkBlockReward();
   const options = {
     blockPayloads: [],
     chainId,
@@ -1125,41 +1232,85 @@ var createForkedHead = /* @__PURE__ */ __name(async (chainSubmissionsArchivistWr
     txs: [],
     protocol,
     reward: forkBlockReward,
-    rewardAddress: forkBlockRewardAddress
+    rewardAddress: account.address
   };
-  const block = await buildBlock(options);
-  const [bw] = block;
-  await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock2(block));
-  while (true) {
-    const result = await chainArchivist.get([
-      bw._hash
-    ]);
-    if (result.length > 0) break;
-    await delay(1e3);
-  }
-  return bw;
+  return await buildBlock(options);
+}, "getFirstBlockForNewChain");
+
+// src/orchestration/services/implementation/head/createForkedHead/createForkedHead.ts
+var createForkedHead = /* @__PURE__ */ __name(async (forkFromBlock, account, chainService) => {
+  const chain = [];
+  const firstBlockForNewChain = await getFirstBlockForNewChain(forkFromBlock, account, chainService);
+  chain.push(firstBlockForNewChain);
+  const bridgeIntent = await getBridgeIntent(firstBlockForNewChain, account, chainService);
+  chain.push(bridgeIntent);
+  const bridgeSourceObservation = await getBridgeSourceObservation(bridgeIntent, account, chainService);
+  chain.push(bridgeSourceObservation);
+  const bridgeDestinationObservation = await getBridgeDestinationObservation(bridgeSourceObservation, account, chainService);
+  chain.push(bridgeDestinationObservation);
+  return chain;
 }, "createForkedHead");
-var initHead = /* @__PURE__ */ __name(async (params) => {
-  const { account, chainArchivist, chainSubmissionsArchivistWrite, chainService } = params;
-  if (headSingleton) return headSingleton;
-  let head = await findMostRecentBlock2(chainArchivist);
-  if (!head) {
-    head = await createBootstrapHead(chainSubmissionsArchivistWrite, chainArchivist, account);
-  } else if (head.chain !== chainService.chainId) {
+
+// src/orchestration/services/implementation/head/getForkFromBlock.ts
+import { asHash, hexFromBigInt } from "@xylabs/hex";
+import { isDefined as isDefined10 } from "@xylabs/typeof";
+import { isBlockBoundWitnessWithHashStorageMeta } from "@xyo-network/chain-sdk";
+var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainArchivist) => {
+  if (head.chain !== chainService.chainId) {
     const forkedAtBigInt = await chainService.forkedAtHash();
     const forkedAtHex = hexFromBigInt(forkedAtBigInt);
     const forkedAtHash = asHash(forkedAtHex);
     if (isDefined10(forkedAtHash)) {
-      const [forkBlock] = await chainArchivist.get([
+      const [forkedAtBlock] = await chainArchivist.get([
         forkedAtHash
       ]);
       const forkedChainId = await chainService.forkedChainId();
       const forkedAtBlockNumber = Number(await chainService.forkedAtBlockNumber());
-      if (isBlockBoundWitnessWithHashStorageMeta(forkBlock) && forkBlock.chain === forkedChainId && forkBlock.block === forkedAtBlockNumber) {
-        head = await createForkedHead(chainSubmissionsArchivistWrite, chainArchivist, account, forkBlock, chainService.chainId);
+      if (isBlockBoundWitnessWithHashStorageMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
+        return forkedAtBlock;
       }
     }
   }
+}, "getForkFromBlock");
+
+// src/orchestration/services/implementation/head/submitNewChain.ts
+import { delay } from "@xylabs/delay";
+import { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
+var submitNewChain = /* @__PURE__ */ __name(async (chain, chainArchivist, chainSubmissionsArchivistWrite) => {
+  for (const block of chain) {
+    const [bw] = block;
+    await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock2(block));
+    while (true) {
+      const result = await chainArchivist.get([
+        bw._hash
+      ]);
+      if (result.length > 0) break;
+      await delay(1e3);
+    }
+  }
+}, "submitNewChain");
+
+// src/orchestration/services/implementation/head/head.ts
+var headSingleton;
+var initHead = /* @__PURE__ */ __name(async (params) => {
+  const { account, chainArchivist, chainSubmissionsArchivistWrite, chainService } = params;
+  if (headSingleton) return headSingleton;
+  let head = await findMostRecentBlock2(chainArchivist);
+  if (head) {
+    const forkFromBlock = await getForkFromBlock(head, chainService, chainArchivist);
+    if (isDefined11(forkFromBlock)) {
+      const chain = await createForkedHead(forkFromBlock, account, chainService);
+      await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
+      const newBlock = assertEx16(chain.at(-1), () => new Error("Failed to get new head after forking"));
+      head = newBlock[0];
+    }
+  } else {
+    const genesisBlock = await createBootstrapHead(account);
+    await submitNewChain([
+      genesisBlock
+    ], chainArchivist, chainSubmissionsArchivistWrite);
+    head = genesisBlock[0];
+  }
   headSingleton = head;
   return headSingleton;
 }, "initHead");
@@ -1204,7 +1355,7 @@ var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
 }, "initBlockProducer");
 
 // src/orchestration/services/implementation/reward.ts
-import { assertEx as assertEx16 } from "@xylabs/assert";
+import { assertEx as assertEx17 } from "@xylabs/assert";
 import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-sdk";
 var rewardServiceSingleton;
 var initBlockRewardService = /* @__PURE__ */ __name((params) => {
@@ -1226,8 +1377,8 @@ var canUseEvmBlockRewardService = /* @__PURE__ */ __name((params) => canUseEvmPr
 var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   const { account: paramsAccount } = params;
-  const account = assertEx16(paramsAccount, () => "Error: Account is required");
-  const provider2 = assertEx16(await initEvmProvider(params));
+  const account = assertEx17(paramsAccount, () => "Error: Account is required");
+  const provider2 = assertEx17(await initEvmProvider(params));
   const evmBlockRewardServiceParams = {
     ...params,
     provider: provider2,
@@ -1337,7 +1488,7 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 
 // src/orchestration/initServices.ts
 var isStartable = /* @__PURE__ */ __name((value) => {
-  return isDefined11(value.start) && typeof value.start === "function";
+  return isDefined12(value.start) && typeof value.start === "function";
 }, "isStartable");
 var initServices = /* @__PURE__ */ __name(async (context) => {
   const { config: config3, logger } = context;
@@ -1463,7 +1614,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     chainArchivist,
     chainIterator
   });
-  const rewardAddress = isDefined11(config3.producer.rewardAddress) ? assertEx17(asAddress2(config3.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
+  const rewardAddress = isDefined12(config3.producer.rewardAddress) ? assertEx18(asAddress2(config3.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
   const producerParams = {
     ...validatorParams,
     name: "Producer",
@@ -1504,7 +1655,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
 
 // src/runCLI.ts
 import { deepMerge } from "@xylabs/object";
-import { isDefined as isDefined14 } from "@xylabs/typeof";
+import { isDefined as isDefined15 } from "@xylabs/typeof";
 import { ConfigZod } from "@xyo-network/xl1-protocol-sdk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -1564,16 +1715,16 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 // src/initLogger.ts
 import { Base as Base2 } from "@xylabs/base";
 import { ConsoleLogger, LogLevel, SilentLogger } from "@xylabs/logger";
-import { isDefined as isDefined12 } from "@xylabs/typeof";
+import { isDefined as isDefined13 } from "@xylabs/typeof";
 var initLogger = /* @__PURE__ */ __name((config3) => {
   let logger;
   if (config3.silent) {
     logger = new SilentLogger();
   } else {
     let level;
-    if (isDefined12(config3.logLevel)) {
+    if (isDefined13(config3.logLevel)) {
       const parsed = LogLevel[config3.logLevel.toLowerCase()];
-      if (isDefined12(parsed)) level = parsed;
+      if (isDefined13(parsed)) level = parsed;
     }
     logger = new ConsoleLogger(level);
   }
@@ -1599,7 +1750,7 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
 }, "optionsFromGlobalZodRegistry");
 
 // src/tryParseConfig.ts
-import { isDefined as isDefined13, isNull } from "@xylabs/typeof";
+import { isDefined as isDefined14, isNull } from "@xylabs/typeof";
 import { cosmiconfigSync } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
@@ -1608,7 +1759,7 @@ var tryParseConfig = /* @__PURE__ */ __name(() => {
   const result = explorer.search();
   if (!isNull(result)) {
     const section = result?.config?.[configSection];
-    if (isDefined13(section) && typeof section === "object") {
+    if (isDefined14(section) && typeof section === "object") {
       return section;
     }
   }
@@ -1638,7 +1789,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var config;
-var version = isDefined14("1.14.1") ? "1.14.1" : "unknown";
+var version = isDefined15("1.14.2") ? "1.14.2" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
   const logger = initLogger(config3);
   const orchestrator = new Orchestrator(logger);