@xyo-network/xl1-cli-lib 1.16.26 → 1.17.0

package/dist/node/index.mjs

@@ -3,7 +3,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/orchestration/actor/implementation/BalanceActor.ts
 import { assertEx } from "@xylabs/sdk-js";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { Mutex } from "async-mutex";
 
 // src/orchestration/actor/model/Actor.ts
@@ -198,17 +197,14 @@ var BalanceActor = class _BalanceActor extends Actor {
   get balanceService() {
     return assertEx(this.params.balance, () => "balanceService not set");
   }
-  get chainIterator() {
-    return assertEx(this.params.chainIterator, () => "chainIterator not set");
+  get blockViewer() {
+    return assertEx(this.params.blockViewer, () => "blockViewer not set");
   }
   static create(params) {
     return new _BalanceActor(params);
   }
   async start() {
     await super.start();
-    this.chainIterator.on("headUpdate", async () => {
-      await this.updateBalance();
-    });
     this.registerTimer(
       "BalanceTimer",
       async () => {
@@ -222,84 +218,21 @@ var BalanceActor = class _BalanceActor extends Actor {
   async updateBalance() {
     if (this._updateMutex.isLocked()) return;
     await this._updateMutex.runExclusive(async () => {
-      const head = await PayloadBuilder.hash(await this.chainIterator.head());
+      const head = await this.blockViewer.currentBlockHash();
       await this.balanceService.accountsBalances([], head);
     });
   }
 };
 
-// src/orchestration/actor/implementation/ChainHeadUpdateActor.ts
-import { assertEx as assertEx2, toHex } from "@xylabs/sdk-js";
-import { findMostRecentBlock, sortBlocks } from "@xyo-network/chain-protocol";
-import { isBlockBoundWitness } from "@xyo-network/xl1-protocol";
-import { Mutex as Mutex2 } from "async-mutex";
-var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
-  static {
-    __name(this, "ChainHeadUpdateActor");
-  }
-  _pollForNewHeadMutex = new Mutex2();
-  constructor(params) {
-    super("ChainHeadUpdate", "ChainHeadUpdate", params);
-  }
-  get chainFinalizedArchivist() {
-    return assertEx2(this.params.chainArchivist, () => "ChainArchivist not set");
-  }
-  get chainIterator() {
-    return assertEx2(this.params.chainIterator, () => "chainIterator not set");
-  }
-  static create(params) {
-    return new _ChainHeadUpdateActor(params);
-  }
-  async start() {
-    await super.start();
-    this.chainFinalizedArchivist.on("inserted", async (data) => {
-      await this.checkInsertedForNewHead(data);
-    });
-    this.registerTimer(
-      "ChainHeadUpdateTimer",
-      async () => await this.pollForNewHead(),
-      0,
-      2500
-      /* 250 */
-    );
-  }
-  async checkInsertedForNewHead(data) {
-    const candidateBlock = sortBlocks(data.payloads.filter(isBlockBoundWitness)).at(-1);
-    await this.updateHeadIfNewer(candidateBlock);
-  }
-  async pollForNewHead() {
-    if (this._pollForNewHeadMutex.isLocked()) {
-      this.logger?.log("Skipping poll for new head, previous poll still in progress");
-      return;
-    }
-    await this._pollForNewHeadMutex.runExclusive(async () => {
-      const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist);
-      await this.updateHeadIfNewer(candidateBlock);
-    });
-  }
-  async updateHeadIfNewer(candidateBlock) {
-    if (!candidateBlock) return;
-    const currentHead = await this.chainIterator.head();
-    const candidateBlockNumber = candidateBlock.block;
-    const candidateBlockNumberDisplay = `0x${toHex(candidateBlockNumber)}`;
-    const currentBlockNumber = currentHead?.block ?? -1;
-    if (candidateBlockNumber > currentBlockNumber) {
-      this.logger?.log("Found more recent head:", candidateBlockNumber, candidateBlockNumberDisplay);
-      await this.chainIterator.updateHead(candidateBlock);
-      this.logger?.log("Updated head:", candidateBlockNumber, candidateBlockNumberDisplay);
-    }
-  }
-};
-
 // src/orchestration/actor/implementation/ProducerActor.ts
-import { assertEx as assertEx3, isDefined, isUndefined, toHex as toHex2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx2, isDefined, isUndefined, toHex } from "@xylabs/sdk-js";
 import { createDeclarationIntent } from "@xyo-network/chain-protocol";
 import { BaseBlockProducerService } from "@xyo-network/chain-services";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { asXL1BlockNumber } from "@xyo-network/xl1-protocol";
 import { buildTransaction, flattenHydratedBlock, flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex3 } from "async-mutex";
+import { Mutex as Mutex2 } from "async-mutex";
 var SHOULD_REGISTER_REDECLARATION_INTENT_TIMER = true;
 var TEN_MINUTES = 10 * 60 * 1e3;
 var ProducerActor = class _ProducerActor extends Actor {
@@ -313,7 +246,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   _producerActorBlockProductionChecks;
   _producerActorBlocksProduced;
   _producerActorBlocksPublished;
-  _produceBlockMutex = new Mutex3();
+  _produceBlockMutex = new Mutex2();
   constructor(params) {
     super(params.producer.address, "Producer", params);
     this._metricAttributes = {
@@ -333,28 +266,28 @@ var ProducerActor = class _ProducerActor extends Actor {
     });
   }
   get account() {
-    return assertEx3(this.params.account, () => "account not set");
+    return assertEx2(this.params.account, () => "account not set");
   }
   get balanceService() {
-    return assertEx3(this.params.balance, () => "balanceService not set");
+    return assertEx2(this.params.balance, () => "balanceService not set");
   }
-  get chainIterator() {
-    return assertEx3(this.params.chainIterator, () => "chainIterator not set");
+  get blockViewer() {
+    return assertEx2(this.params.blockViewer, () => "blockViewer not set");
   }
   get chainStakeViewer() {
-    return assertEx3(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx2(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get chainSubmissionsArchivistWrite() {
-    return assertEx3(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
+    return assertEx2(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
   }
   get pendingBundledTransactionsArchivistWrite() {
-    return assertEx3(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
+    return assertEx2(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
   }
   get producer() {
-    return assertEx3(this.params.producer, () => "producer not set");
+    return assertEx2(this.params.producer, () => "producer not set");
   }
   get stakeIntentService() {
-    return assertEx3(this.params.stakeIntent, () => "stakeIntentService not set");
+    return assertEx2(this.params.stakeIntent, () => "stakeIntentService not set");
   }
   static create(params) {
     return new _ProducerActor(params);
@@ -395,12 +328,12 @@ var ProducerActor = class _ProducerActor extends Actor {
       }
       await this._produceBlockMutex.runExclusive(async () => {
         const headStart = Date.now();
-        const head = await this.chainIterator.head();
+        const head = (await this.blockViewer.currentBlock())[0];
         const headDuration = Date.now() - headStart;
-        if (headDuration > 500) this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex2(head._hash)}`);
+        if (headDuration > 500) this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex(head._hash)}`);
         const headHash = head._hash;
         if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
-          this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`, this._lastProducedBlock[0].block);
+          this.logger?.log("Block already produced:", `0x${toHex(this._lastProducedBlock[0].block)}`, this._lastProducedBlock[0].block);
         } else {
           this._producerActorBlockProductionAttempts?.add(1, this._metricAttributes);
           const nextStart = Date.now();
@@ -408,7 +341,7 @@ var ProducerActor = class _ProducerActor extends Actor {
           const nextDuration = Date.now() - nextStart;
           if (nextDuration > 1e3) this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`);
           if (nextBlock) {
-            const displayBlockNumber = `0x${toHex2(nextBlock[0].block)}`;
+            const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`;
             this.logger?.log("Produced block:", displayBlockNumber);
             this._producerActorBlocksProduced?.add(1, this._metricAttributes);
             await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
@@ -423,7 +356,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   async redeclareIntent() {
     await this.spanAsync("redeclareIntent", async () => {
       if (this.params.config.producer.disableIntentRedeclaration) return;
-      const head = await this.chainIterator.head();
+      const head = (await this.blockViewer.currentBlock())[0];
       if (isUndefined(head)) return;
       const currentBlock = head.block;
       const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock);
@@ -451,12 +384,12 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   async submitRedeclarationIntent(currentBlock, redeclarationIntent) {
     this.logger?.log("Submitting redeclaration intent for producer:", this.account.address);
-    const tx = await buildTransaction(this.chainIterator.chainId, [
+    const tx = await buildTransaction(await this.chainStakeViewer.chainId(), [
       redeclarationIntent
     ], [], this.account, currentBlock, asXL1BlockNumber(currentBlock + 1e3, true));
     const payloads = flattenHydratedTransaction(tx);
     const root = tx[0]._hash;
-    const payloadBundle = new PayloadBuilder2({
+    const payloadBundle = new PayloadBuilder({
       schema: PayloadBundleSchema
     }).fields({
       payloads,
@@ -494,8 +427,8 @@ var ProducerActor = class _ProducerActor extends Actor {
 };
 
 // src/orchestration/actor/implementation/ValidatorActor.ts
-import { assertEx as assertEx4, isDefined as isDefined2, isUndefined as isUndefined2, toHex as toHex3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx3, isDefined as isDefined2, isUndefined as isUndefined2, toHex as toHex2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 var ValidatorActor = class _ValidatorActor extends Actor {
   static {
     __name(this, "ValidatorActor");
@@ -506,25 +439,25 @@ var ValidatorActor = class _ValidatorActor extends Actor {
     super("Validator", "Validator", params);
   }
   get account() {
-    return assertEx4(this.params.account, () => "account not set");
+    return assertEx3(this.params.account, () => "account not set");
   }
   get balanceService() {
-    return assertEx4(this.params.balance, () => "balanceService not set");
+    return assertEx3(this.params.balance, () => "balanceService not set");
   }
-  get chainIterator() {
-    return assertEx4(this.params.chainIterator, () => "chainIterator not set");
+  get blockViewer() {
+    return assertEx3(this.params.blockViewer, () => "blockViewer not set");
   }
   get chainStakeViewer() {
-    return assertEx4(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx3(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get chainSubmissionsArchivistWrite() {
-    return assertEx4(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
+    return assertEx3(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
   }
   get pendingBundledTransactionsArchivistWrite() {
-    return assertEx4(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
+    return assertEx3(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
   }
   get stakeIntentService() {
-    return assertEx4(this.params.stakeIntent, () => "stakeIntentService not set");
+    return assertEx3(this.params.stakeIntent, () => "stakeIntentService not set");
   }
   // protected get validator() {
   //   return assertEx(this.params.validator, () => 'validator not set')
@@ -538,18 +471,18 @@ var ValidatorActor = class _ValidatorActor extends Actor {
       "BlockProductionTimer",
       async () => {
         await this.spanAsync("produceBlock", async () => {
-          const block = await this.chainIterator.head();
+          const block = (await this.blockViewer.currentBlock())[0];
           if (isUndefined2(block)) return;
-          const hash = await PayloadBuilder3.hash(block);
+          const hash = await PayloadBuilder2.hash(block);
           if (isDefined2(this._lastValidatedBlock) && this._lastValidatedBlockHash === hash) {
-            this.logger?.log("Block already validated:", `0x${toHex3(block.block)}`);
+            this.logger?.log("Block already validated:", `0x${toHex2(block.block)}`);
           } else {
-            this.logger?.log("Validating block:", `0x${toHex3(block.block)}`);
+            this.logger?.log("Validating block:", `0x${toHex2(block.block)}`);
             const valid = await this.validateBlock(block);
             if (valid) {
-              this.logger?.log("Validated block:", `0x${toHex3(block.block)}`);
+              this.logger?.log("Validated block:", `0x${toHex2(block.block)}`);
             } else {
-              this.logger?.log("Invalid block:", `0x${toHex3(block.block)}`);
+              this.logger?.log("Invalid block:", `0x${toHex2(block.block)}`);
               await this.slashInvalidBlock(block);
             }
           }
@@ -567,7 +500,7 @@ var ValidatorActor = class _ValidatorActor extends Actor {
   async validateBlock(block) {
     const valid = await Promise.resolve(true);
     this._lastValidatedBlock = block;
-    this._lastValidatedBlockHash = await PayloadBuilder3.hash(block);
+    this._lastValidatedBlockHash = await PayloadBuilder2.hash(block);
     return valid;
   }
 };
@@ -629,25 +562,12 @@ var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
 }, "initHealthEndpoints");
 
 // src/orchestration/initServices.ts
-import { asAddress as asAddress2, assertEx as assertEx19, isDefined as isDefined14 } from "@xylabs/sdk-js";
-import { initChainIterator, initElectionService, initProducerAccount, initStakeIntentService } from "@xyo-network/chain-orchestration";
-import { blockViewerFromChainIteratorAndArchivist } from "@xyo-network/chain-services";
+import { asAddress as asAddress2, assertEx as assertEx17, isDefined as isDefined17 } from "@xylabs/sdk-js";
+import { initElectionService, initProducerAccount, initStakeIntentService } from "@xyo-network/chain-orchestration";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
-import { startupSpanAsync as startupSpanAsync8 } from "@xyo-network/chain-utils";
+import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
 import { validateHydratedBlockState } from "@xyo-network/chain-validation";
-import { StepSizes } from "@xyo-network/xl1-protocol";
-import { readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { CompletedStepRewardAddressValidatorFactory, DerivedReceiveAddressValidatorFactory, SelfSignerValidator, TransactionTransfersValidatorFactory } from "@xyo-network/xl1-validation";
-import { Semaphore as Semaphore2 } from "async-mutex";
-
-// src/orchestration/archivists/ChainFinalized/archivist.ts
-import { initArchivistSync } from "@xyo-network/chain-orchestration";
-import { startupSpanAsync } from "@xyo-network/chain-utils";
-import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex6 } from "async-mutex";
-
-// src/orchestration/archivists/ChainFinalized/local.ts
-import { Mutex as Mutex4 } from "async-mutex";
 
 // src/orchestration/archivists/lib/localPersistentArchivist.ts
 import { rm } from "fs/promises";
@@ -674,120 +594,62 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
   }
 }, "getLocalPersistentArchivist");
 
-// src/orchestration/archivists/ChainFinalized/local.ts
-var mutex = new Mutex4();
-var singleton;
-var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex.runExclusive(async () => {
-    if (singleton) return singleton;
-    const { root } = config2.storage;
-    singleton = await getLocalPersistentArchivist("local-finalized-chain", "chain", "finalized", root);
-    return singleton;
-  });
-}, "initLocalChainFinalizedArchivist");
-
-// src/orchestration/archivists/ChainFinalized/remote.ts
+// src/orchestration/archivists/ChainSubmissions/archivist.ts
 import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { startupSpanAsync } from "@xyo-network/chain-utils";
+import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex4 } from "async-mutex";
+
+// src/orchestration/archivists/ChainSubmissions/remote.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { initBridge, initBridgedArchivistModule } from "@xyo-network/chain-orchestration";
 import { getUrl } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex5 } from "async-mutex";
-var mutex2 = new Mutex5();
-var singleton2;
-var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex2.runExclusive(async () => {
-    if (singleton2) return singleton2;
+import { Mutex as Mutex3 } from "async-mutex";
+var mutex = new Mutex3();
+var singleton;
+var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton;
     const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
     const nodeUrl = getUrl(host, port);
     const bridge = await initBridge(nodeUrl);
-    singleton2 = await initBridgedArchivistModule({
-      bridge,
-      moduleName: "XYOChain:Chain:Finalized"
-    });
-    return assertEx5(singleton2, () => "RemoteChainFinalizedArchivist failed to initialize");
-  });
-}, "initRemoteChainFinalizedArchivist");
-
-// src/orchestration/archivists/ChainFinalized/archivist.ts
-var mutex3 = new Mutex6();
-var singleton3;
-async function initChainFinalizedArchivist({ config: config2, logger, traceProvider }) {
-  return await mutex3.runExclusive(async () => {
-    if (singleton3) return singleton3;
-    return await timeBudget("initChainFinalizedArchivist", logger, async () => {
-      const [remote, local] = await Promise.all([
-        startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({
-          config: config2,
-          logger
-        })),
-        startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
-          config: config2,
-          logger
-        }))
-      ]);
-      await startupSpanAsync("ChainFinalizedArchivist:initArchivistSync", () => initArchivistSync("ChainFinalizedArchivist", remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider));
-      singleton3 = local;
-      return singleton3;
-    }, 2e3, true);
-  });
-}
-__name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
-
-// src/orchestration/archivists/ChainSubmissions/archivist.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex8 } from "async-mutex";
-
-// src/orchestration/archivists/ChainSubmissions/remote.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { initBridge as initBridge2, initBridgedArchivistModule as initBridgedArchivistModule2 } from "@xyo-network/chain-orchestration";
-import { getUrl as getUrl2 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex7 } from "async-mutex";
-var mutex4 = new Mutex7();
-var singleton4;
-var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex4.runExclusive(async () => {
-    if (singleton4) return singleton4;
-    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
-    const nodeUrl = getUrl2(host, port);
-    const bridge = await initBridge2(nodeUrl);
-    singleton4 = await initBridgedArchivistModule2({
+    singleton = await initBridgedArchivistModule({
       bridge,
       moduleName: "XYOChain:Chain:Submissions"
     });
-    return assertEx6(singleton4, () => new Error("Failed to initialize RemoteChainSubmissionsArchivist"));
+    return assertEx4(singleton, () => new Error("Failed to initialize RemoteChainSubmissionsArchivist"));
   });
 }, "initRemoteChainSubmissionsArchivist");
 
 // src/orchestration/archivists/ChainSubmissions/archivist.ts
-var mutex5 = new Mutex8();
-var singleton5;
+var mutex2 = new Mutex4();
+var singleton2;
 var initChainSubmissionsArchivist = /* @__PURE__ */ __name(async (params) => {
-  return await mutex5.runExclusive(async () => {
-    if (singleton5) return singleton5;
-    return await timeBudget2("initChainSubmissionsArchivist", params.logger, async () => {
-      const remote = await startupSpanAsync2("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
-      singleton5 = remote;
-      return assertEx7(singleton5, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
+  return await mutex2.runExclusive(async () => {
+    if (singleton2) return singleton2;
+    return await timeBudget("initChainSubmissionsArchivist", params.logger, async () => {
+      const remote = await startupSpanAsync("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
+      singleton2 = remote;
+      return assertEx5(singleton2, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
     }, 2e3, true);
   });
 }, "initChainSubmissionsArchivist");
 
 // src/orchestration/archivists/PendingTransactions/archivist.ts
-import { initArchivistSync as initArchivistSync2 } from "@xyo-network/chain-orchestration";
-import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex11 } from "async-mutex";
+import { initArchivistSync } from "@xyo-network/chain-orchestration";
+import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex7 } from "async-mutex";
 
 // src/orchestration/archivists/PendingTransactions/local.ts
 import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex9 } from "async-mutex";
-var mutex6 = new Mutex9();
-var singleton6;
+import { Mutex as Mutex5 } from "async-mutex";
+var mutex3 = new Mutex5();
+var singleton3;
 var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
-  return await mutex6.runExclusive(async () => {
-    if (singleton6) return singleton6;
-    singleton6 = await MemoryArchivist.create({
+  return await mutex3.runExclusive(async () => {
+    if (singleton3) return singleton3;
+    singleton3 = await MemoryArchivist.create({
       account: "random",
       config: {
         schema: MemoryArchivistConfigSchema,
@@ -795,43 +657,43 @@ var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
         name: "localPendingTransactions"
       }
     });
-    return singleton6;
+    return singleton3;
   });
 }, "initLocalPendingTransactionsArchivist");
 
 // src/orchestration/archivists/PendingTransactions/remote.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
-import { initBridge as initBridge3, initBridgedArchivistModule as initBridgedArchivistModule3 } from "@xyo-network/chain-orchestration";
-import { getUrl as getUrl3 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex10 } from "async-mutex";
-var mutex7 = new Mutex10();
-var singleton7;
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { initBridge as initBridge2, initBridgedArchivistModule as initBridgedArchivistModule2 } from "@xyo-network/chain-orchestration";
+import { getUrl as getUrl2 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex6 } from "async-mutex";
+var mutex4 = new Mutex6();
+var singleton4;
 var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex7.runExclusive(async () => {
-    if (singleton7) return singleton7;
+  return await mutex4.runExclusive(async () => {
+    if (singleton4) return singleton4;
     const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
-    const nodeUrl = getUrl3(host, port);
-    const bridge = await initBridge3(nodeUrl);
-    singleton7 = await initBridgedArchivistModule3({
+    const nodeUrl = getUrl2(host, port);
+    const bridge = await initBridge2(nodeUrl);
+    singleton4 = await initBridgedArchivistModule2({
       bridge,
       moduleName: "XYOChain:Pending:PendingTransactions"
     });
-    return assertEx8(singleton7, () => "RemotePendingBundledTransactionsArchivist is undefined");
+    return assertEx6(singleton4, () => "RemotePendingBundledTransactionsArchivist is undefined");
   });
 }, "initRemotePendingTransactionsArchivist");
 
 // src/orchestration/archivists/PendingTransactions/archivist.ts
-var mutex8 = new Mutex11();
-var singleton8;
+var mutex5 = new Mutex7();
+var singleton5;
 var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2, logger }) => {
-  return await mutex8.runExclusive(async () => {
-    if (singleton8) return singleton8;
-    return await timeBudget3("initPendingBundledTransactionsArchivist", logger, async () => {
-      const remote = await startupSpanAsync3("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist({
+  return await mutex5.runExclusive(async () => {
+    if (singleton5) return singleton5;
+    return await timeBudget2("initPendingBundledTransactionsArchivist", logger, async () => {
+      const remote = await startupSpanAsync2("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist({
         config: config2,
         logger
       }));
-      const local = await startupSpanAsync3("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
+      const local = await startupSpanAsync2("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
         config: config2,
         logger
       }));
@@ -840,30 +702,30 @@ var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async ({ co
         order: "desc"
       });
       await local.insert(start2);
-      await startupSpanAsync3("PendingBundledTransactionsArchivist:initArchivistSync", () => initArchivistSync2("PendingBundledTransactionsArchivist", remote, local));
-      singleton8 = [
+      await startupSpanAsync2("PendingBundledTransactionsArchivist:initArchivistSync", () => initArchivistSync("PendingBundledTransactionsArchivist", remote, local));
+      singleton5 = [
         local,
         remote
       ];
-      return singleton8;
+      return singleton5;
     }, 2e3, true);
   });
 }, "initPendingBundledTransactionsArchivist");
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
-import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget4 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex13 } from "async-mutex";
+import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex9 } from "async-mutex";
 
 // src/orchestration/archivists/RejectedTransactions/local.ts
 import { MemoryArchivist as MemoryArchivist2, MemoryArchivistConfigSchema as MemoryArchivistConfigSchema2 } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex12 } from "async-mutex";
-var mutex9 = new Mutex12();
-var singleton9;
+import { Mutex as Mutex8 } from "async-mutex";
+var mutex6 = new Mutex8();
+var singleton6;
 var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
-  return await mutex9.runExclusive(async () => {
-    if (singleton9) return singleton9;
-    singleton9 = await MemoryArchivist2.create({
+  return await mutex6.runExclusive(async () => {
+    if (singleton6) return singleton6;
+    singleton6 = await MemoryArchivist2.create({
       account: "random",
       config: {
         schema: MemoryArchivistConfigSchema2,
@@ -871,90 +733,90 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
         name: "localRejectedTransactions"
       }
     });
-    return singleton9;
+    return singleton6;
   });
 }, "initLocalRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
-var mutex10 = new Mutex13();
-var singleton10;
+var mutex7 = new Mutex9();
+var singleton7;
 async function initRejectedTransactionsArchivist(params) {
-  return await mutex10.runExclusive(async () => {
-    if (singleton10) return singleton10;
-    return await timeBudget4("initRejectedTransactionsArchivist", params.logger, async () => {
-      const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
-      singleton10 = local;
-      return singleton10;
+  return await mutex7.runExclusive(async () => {
+    if (singleton7) return singleton7;
+    return await timeBudget3("initRejectedTransactionsArchivist", params.logger, async () => {
+      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+      singleton7 = local;
+      return singleton7;
     }, 2e3, true);
   });
 }
 __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex15 } from "async-mutex";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget4 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex11 } from "async-mutex";
 
 // src/orchestration/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
-import { Mutex as Mutex14 } from "async-mutex";
-var mutex11 = new Mutex14();
-var singleton11;
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { Mutex as Mutex10 } from "async-mutex";
+var mutex8 = new Mutex10();
+var singleton8;
 var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex11.runExclusive(async () => {
-    if (singleton11) return singleton11;
+  return await mutex8.runExclusive(async () => {
+    if (singleton8) return singleton8;
     const { root } = config2.storage;
-    singleton11 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
-    return assertEx9(singleton11, () => new Error("Failed to initialize stake intent state archivist"));
+    singleton8 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
+    return assertEx7(singleton8, () => new Error("Failed to initialize stake intent state archivist"));
   });
 }, "initLocalStakeIntentStateArchivist");
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
-var mutex12 = new Mutex15();
-var singleton12;
+var mutex9 = new Mutex11();
+var singleton9;
 var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (params) => {
-  return await mutex12.runExclusive(async () => {
-    if (singleton12) return singleton12;
-    return await timeBudget5("initStakeIntentStateArchivist", params.logger, async () => {
-      const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
-      singleton12 = local;
-      return assertEx10(singleton12, () => "StakeIntentStateArchivist is undefined");
+  return await mutex9.runExclusive(async () => {
+    if (singleton9) return singleton9;
+    return await timeBudget4("initStakeIntentStateArchivist", params.logger, async () => {
+      const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
+      singleton9 = local;
+      return assertEx8(singleton9, () => "StakeIntentStateArchivist is undefined");
     }, 2e3, true);
   });
 }, "initStakeIntentStateArchivist");
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
 import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget6 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex17 } from "async-mutex";
+import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex13 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/initLocalBalanceSummaryMap.ts
 import { isDefined as isDefined4 } from "@xylabs/sdk-js";
 import { getLocalPersistentMap } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex16 } from "async-mutex";
-var mutex13 = new Mutex16();
-var singleton13;
+import { Mutex as Mutex12 } from "async-mutex";
+var mutex10 = new Mutex12();
+var singleton10;
 var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async (params) => {
-  return await mutex13.runExclusive(async () => {
-    if (isDefined4(singleton13)) return singleton13;
+  return await mutex10.runExclusive(async () => {
+    if (isDefined4(singleton10)) return singleton10;
     const { root } = params.config.storage;
-    singleton13 = await getLocalPersistentMap("balance", "summary", root);
-    return singleton13;
+    singleton10 = await getLocalPersistentMap("balance", "summary", root);
+    return singleton10;
   });
 }, "initLocalBalanceSummaryMap");
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
-var mutex14 = new Mutex17();
-var singleton14;
+var mutex11 = new Mutex13();
+var singleton11;
 async function initBalanceSummaryMap(params) {
-  return await mutex14.runExclusive(async () => {
-    if (isDefined5(singleton14)) return singleton14;
-    return await timeBudget6("initBalanceSummaryMap", params.logger, async () => {
-      const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
-      singleton14 = local;
-      return singleton14;
+  return await mutex11.runExclusive(async () => {
+    if (isDefined5(singleton11)) return singleton11;
+    return await timeBudget5("initBalanceSummaryMap", params.logger, async () => {
+      const local = await startupSpanAsync5("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
+      singleton11 = local;
+      return singleton11;
     }, 2e3, true);
   });
 }
@@ -962,77 +824,103 @@ __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
 import { isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget7 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex19 } from "async-mutex";
+import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget6 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex15 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/initLocalTransferSummaryMap.ts
 import { isDefined as isDefined6 } from "@xylabs/sdk-js";
 import { getLocalPersistentMap as getLocalPersistentMap2 } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex18 } from "async-mutex";
-var mutex15 = new Mutex18();
-var singleton15;
+import { Mutex as Mutex14 } from "async-mutex";
+var mutex12 = new Mutex14();
+var singleton12;
 var initLocalTransferSummaryMap = /* @__PURE__ */ __name(async (params) => {
-  return await mutex15.runExclusive(async () => {
-    if (isDefined6(singleton15)) return singleton15;
+  return await mutex12.runExclusive(async () => {
+    if (isDefined6(singleton12)) return singleton12;
     const { root } = params.config.storage;
-    singleton15 = await getLocalPersistentMap2("transfer", "summary", root);
-    return singleton15;
+    singleton12 = await getLocalPersistentMap2("transfer", "summary", root);
+    return singleton12;
   });
 }, "initLocalTransferSummaryMap");
 
 // src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
-var mutex16 = new Mutex19();
-var singleton16;
+var mutex13 = new Mutex15();
+var singleton13;
 async function initTransferSummaryMap(params) {
-  return await mutex16.runExclusive(async () => {
-    if (isDefined7(singleton16)) return singleton16;
-    return await timeBudget7("initTransferSummaryMap:Init", params.logger, async () => {
-      const local = await startupSpanAsync7("TransferSummaryMap:initLocal", () => initLocalTransferSummaryMap(params));
-      singleton16 = local;
-      return singleton16;
+  return await mutex13.runExclusive(async () => {
+    if (isDefined7(singleton13)) return singleton13;
+    return await timeBudget6("initTransferSummaryMap:Init", params.logger, async () => {
+      const local = await startupSpanAsync6("TransferSummaryMap:initLocal", () => initLocalTransferSummaryMap(params));
+      singleton13 = local;
+      return singleton13;
     }, 2e3, true);
   });
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 
 // src/orchestration/services/implementation/accountBalance.ts
-import { BaseAccountBalanceService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget8 } from "@xyo-network/xl1-protocol-sdk";
+import { isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { AccountBalanceViewerRpcSchemas, HttpRpcTransport, JsonRpcAccountBalanceViewer } from "@xyo-network/xl1-rpc";
 var balanceServiceSingleton;
-var initAccountBalanceService = /* @__PURE__ */ __name(async (params) => {
+var initAccountBalanceService = /* @__PURE__ */ __name((params) => {
   const { config: config2, logger } = params;
   if (balanceServiceSingleton) return balanceServiceSingleton;
-  return await timeBudget8("initAccountBalanceService", params.logger, async () => {
-    const endpoint = config2.services?.accountBalanceViewerEndpoint ?? config2.services?.apiEndpoint;
-    balanceServiceSingleton = await BaseAccountBalanceService.create(params.params);
-    return balanceServiceSingleton;
-  }, 2e3, true);
+  const endpoint = config2.services?.accountBalanceViewerEndpoint ?? config2.services?.apiEndpoint;
+  if (isDefined8(endpoint)) {
+    const transport = new HttpRpcTransport(endpoint, {
+      ...AccountBalanceViewerRpcSchemas
+    });
+    const viewer = new JsonRpcAccountBalanceViewer(transport);
+    logger?.log("Using AccountBalanceViewer RPC service at", endpoint);
+    return viewer;
+  } else {
+    throw new Error("No AccountBalanceViewer endpoint configured");
+  }
 }, "initAccountBalanceService");
 
+// src/orchestration/services/implementation/blockViewer.ts
+import { isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { BlockViewerRpcSchemas, HttpRpcTransport as HttpRpcTransport2, JsonRpcBlockViewer } from "@xyo-network/xl1-rpc";
+var blockViewerSingleton;
+var initBlockViewer = /* @__PURE__ */ __name((params) => {
+  const { config: config2, logger } = params;
+  if (blockViewerSingleton) return blockViewerSingleton;
+  const endpoint = config2.services?.apiEndpoint;
+  if (isDefined9(endpoint)) {
+    const transport = new HttpRpcTransport2(endpoint, {
+      ...BlockViewerRpcSchemas
+    });
+    const viewer = new JsonRpcBlockViewer(transport);
+    logger?.log("Using BlockViewer RPC service at", endpoint);
+    return viewer;
+  } else {
+    throw new Error("No BlockViewer endpoint configured");
+  }
+}, "initBlockViewer");
+
 // src/orchestration/services/implementation/chain/index.ts
-import { assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import { MemoryChainService } from "@xyo-network/chain-services";
 
 // src/orchestration/services/implementation/chain/evm.ts
-import { asAddress, assertEx as assertEx15, isDefined as isDefined11, ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx13, isDefined as isDefined13, ZERO_ADDRESS } from "@xylabs/sdk-js";
 import { EvmChainService } from "@xyo-network/chain-services";
 import { Wallet } from "ethers/wallet";
 
 // src/orchestration/services/implementation/evm/initEvmProvider.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 
 // src/orchestration/services/implementation/evm/initInfuraProvider.ts
-import { assertEx as assertEx12, isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined11 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 
 // src/orchestration/services/implementation/evm/initChainId.ts
-import { assertEx as assertEx11, hexFrom, isDefined as isDefined8, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx9, hexFrom, isDefined as isDefined10, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name((config2) => {
-  return isDefined8(config2.evm.chainId);
+  return isDefined10(config2.evm.chainId);
 }, "canUseChainId");
 var getChainId = /* @__PURE__ */ __name((config2) => {
-  const chainId = assertEx11(config2.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx9(config2.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -1054,11 +942,11 @@ var initInfuraProvider = /* @__PURE__ */ __name((config2) => {
   return instance;
 }, "initInfuraProvider");
 var canUseInfuraProvider = /* @__PURE__ */ __name((config2) => {
-  return canUseChainId(config2) && isDefined9(config2.evm?.infura?.projectId) && isDefined9(config2.evm?.infura?.projectSecret);
+  return canUseChainId(config2) && isDefined11(config2.evm?.infura?.projectId) && isDefined11(config2.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
 var getInfuraProviderConfig = /* @__PURE__ */ __name((config2) => {
-  const projectId = assertEx12(config2.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx12(config2.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx10(config2.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx10(config2.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config2),
     projectId,
@@ -1067,17 +955,17 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config2) => {
 }, "getInfuraProviderConfig");
 
 // src/orchestration/services/implementation/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx13, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, isDefined as isDefined12 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
   const providerConfig = getJsonRpcProviderConfig(config2);
   return Promise.resolve(new JsonRpcProvider(...providerConfig));
 }, "initJsonRpcProvider");
 var canUseJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
-  return canUseChainId(config2) && isDefined10(config2.evm.jsonRpc?.url);
+  return canUseChainId(config2) && isDefined12(config2.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config2) => {
-  const jsonRpcUrl = assertEx13(config2.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx11(config2.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config2)
@@ -1093,7 +981,7 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   } else if (canUseJsonRpcProvider(config2)) {
     provider = initJsonRpcProvider(config2);
   }
-  return assertEx14(await provider, () => "No provider available");
+  return assertEx12(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config2 }) => {
   return canUseInfuraProvider(config2) || canUseJsonRpcProvider(config2);
@@ -1103,18 +991,18 @@ var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config2 }) => {
 var chainStakeServiceSingleton;
 var canUseEvmContractChainService = /* @__PURE__ */ __name((config2) => {
   const { id } = config2.chain;
-  return isDefined11(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
+  return isDefined13(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
     config: config2
   });
 }, "canUseEvmContractChainService");
 var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config: config2, traceProvider, meterProvider, logger }) => {
   if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
-  const emvStakingContractAddress = assertEx15(config2.chain.id, () => "config.chain.id is required");
-  const id = assertEx15(asAddress(emvStakingContractAddress), () => "config.chain.id is not a valid address");
-  const provider2 = assertEx15(await initEvmProvider({
+  const emvStakingContractAddress = assertEx13(config2.chain.id, () => "config.chain.id is required");
+  const id = assertEx13(asAddress(emvStakingContractAddress), () => "config.chain.id is not a valid address");
+  const provider2 = assertEx13(await initEvmProvider({
     config: config2
   }));
-  const privateKey = assertEx15(account.private?.hex, () => "Account does not have a private key");
+  const privateKey = assertEx13(account.private?.hex, () => "Account does not have a private key");
   const runner = new Wallet(privateKey, provider2);
   chainStakeServiceSingleton = EvmChainService.create({
     id,
@@ -1145,7 +1033,7 @@ var initMemoryChainService = /* @__PURE__ */ __name(async ({ config: config2 })
     config: config2,
     name: "MemoryChainService"
   });
-  assertEx16(await result.start(), () => "Failed to start MemoryChainService");
+  assertEx14(await result.start(), () => "Failed to start MemoryChainService");
   return result;
 }, "initMemoryChainService");
 var init = /* @__PURE__ */ __name(async (params) => {
@@ -1159,13 +1047,13 @@ var init = /* @__PURE__ */ __name(async (params) => {
 }, "init");
 
 // src/orchestration/services/implementation/head/head.ts
-import { assertEx as assertEx17, isDefined as isDefined13 } from "@xylabs/sdk-js";
-import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
+import { assertEx as assertEx15, isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { findMostRecentBlock } from "@xyo-network/xl1-protocol-sdk";
 
 // src/orchestration/services/implementation/head/createBootstrapHead.ts
 import { buildNextBlock, createDeclarationIntent as createDeclarationIntent2, createGenesisBlock } from "@xyo-network/chain-protocol";
 var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainService) => {
-  const chainId = chainService.chainId;
+  const chainId = await chainService.chainId();
   const chain = [];
   const genesisBlock = await createGenesisBlock(account, chainId, 10000000n, account.address);
   chain.push(genesisBlock);
@@ -1181,27 +1069,27 @@ var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainService) =
 
 // src/orchestration/services/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
 import { buildNextBlock as buildNextBlock2 } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { BridgeDestinationObservationSchema } from "@xyo-network/xl1-protocol";
 
 // src/orchestration/services/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
-import { toHex as toHex5 } from "@xylabs/sdk-js";
+import { toHex as toHex4 } from "@xylabs/sdk-js";
 
 // src/orchestration/services/implementation/head/createForkedHead/config/getForkDetails.ts
-import { toHex as toHex4 } from "@xylabs/sdk-js";
+import { toHex as toHex3 } from "@xylabs/sdk-js";
 import { AttoXL1ConvertFactor } from "@xyo-network/xl1-protocol";
 var getForkBlockReward = /* @__PURE__ */ __name(() => {
   return 18000000000n * AttoXL1ConvertFactor.xl1;
 }, "getForkBlockReward");
 var getForkBlockRewardHex = /* @__PURE__ */ __name(() => {
-  return toHex4(getForkBlockReward());
+  return toHex3(getForkBlockReward());
 }, "getForkBlockRewardHex");
 
 // src/orchestration/services/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts
-var ethChainId = toHex5("0x1");
-var bridgeableTokenContract = toHex5("0xf72aE3E0DA743033AbD7A407557D684c1aE66aed");
-var bridgeDestAddress = toHex5("0x0e65b65B10C791942665030402c35023d88B14dA");
-var destConfirmation = toHex5("0x950861b10523b52cdbb4a9ee52ed26601db555d2652bfec21c709e5e70d5b7d3");
+var ethChainId = toHex4("0x1");
+var bridgeableTokenContract = toHex4("0xf72aE3E0DA743033AbD7A407557D684c1aE66aed");
+var bridgeDestAddress = toHex4("0x0e65b65B10C791942665030402c35023d88B14dA");
+var destConfirmation = toHex4("0x950861b10523b52cdbb4a9ee52ed26601db555d2652bfec21c709e5e70d5b7d3");
 var getBridgeDestChainId = /* @__PURE__ */ __name(() => ethChainId, "getBridgeDestChainId");
 var getBridgeDestToken = /* @__PURE__ */ __name(() => bridgeableTokenContract, "getBridgeDestToken");
 var getBridgeDestAddress = /* @__PURE__ */ __name(() => bridgeDestAddress, "getBridgeDestAddress");
@@ -1217,15 +1105,15 @@ var getBridgeDestinationDetails = /* @__PURE__ */ __name(() => {
 }, "getBridgeDestinationDetails");
 
 // src/orchestration/services/implementation/head/createForkedHead/config/getBridgeSourceDetails.ts
-var getBridgeSrcChainId = /* @__PURE__ */ __name((chainService) => chainService.chainId, "getBridgeSrcChainId");
+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 getBridgeSrcToken = /* @__PURE__ */ __name((chainService) => chainService.chainId(), "getBridgeSrcToken");
 var getBridgeSrcAmount = /* @__PURE__ */ __name(() => getForkBlockRewardHex(), "getBridgeSrcAmount");
-var getBridgeSourceDetails = /* @__PURE__ */ __name((account, chainService) => {
+var getBridgeSourceDetails = /* @__PURE__ */ __name(async (account, chainService) => {
   return {
-    src: getBridgeSrcChainId(chainService),
+    src: await getBridgeSrcChainId(chainService),
     srcAddress: getBridgeSrcAddress(account),
-    srcToken: getBridgeSrcToken(chainService),
+    srcToken: await getBridgeSrcToken(chainService),
     srcAmount: getBridgeSrcAmount()
   };
 }, "getBridgeSourceDetails");
@@ -1233,11 +1121,11 @@ var getBridgeSourceDetails = /* @__PURE__ */ __name((account, chainService) => {
 // src/orchestration/services/implementation/head/createForkedHead/getBridgeDestinationObservation.ts
 var getBridgeDestinationObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
   const bridgeDestinationObservationFields = {
-    ...getBridgeSourceDetails(account, chainService),
+    ...await getBridgeSourceDetails(account, chainService),
     ...getBridgeDestinationDetails(),
     destConfirmation: getBridgeDestConfirmation()
   };
-  const bridgeDestinationObservation = new PayloadBuilder4({
+  const bridgeDestinationObservation = new PayloadBuilder3({
     schema: BridgeDestinationObservationSchema
   }).fields(bridgeDestinationObservationFields).build();
   return await buildNextBlock2(previousBlock[0], [], [
@@ -1249,7 +1137,7 @@ var getBridgeDestinationObservation = /* @__PURE__ */ __name(async (previousBloc
 
 // src/orchestration/services/implementation/head/createForkedHead/getBridgeIntent.ts
 import { buildNextBlock as buildNextBlock3, createTransferPayload } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { BridgeIntentSchema, XYO_BRIDGE_ADDRESS } from "@xyo-network/xl1-protocol";
 var getBridgeIntent = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
   const transferPayload = createTransferPayload(account.address, {
@@ -1257,11 +1145,11 @@ var getBridgeIntent = /* @__PURE__ */ __name(async (previousBlock, account, chai
   });
   const nonce = `${Date.now()}`;
   const bridgeIntentFields = {
-    ...getBridgeSourceDetails(account, chainService),
+    ...await getBridgeSourceDetails(account, chainService),
     ...getBridgeDestinationDetails(),
     nonce
   };
-  const bridgeIntent = new PayloadBuilder5({
+  const bridgeIntent = new PayloadBuilder4({
     schema: BridgeIntentSchema
   }).fields(bridgeIntentFields).build();
   return await buildNextBlock3(previousBlock[0], [], [
@@ -1274,17 +1162,17 @@ var getBridgeIntent = /* @__PURE__ */ __name(async (previousBlock, account, chai
 
 // src/orchestration/services/implementation/head/createForkedHead/getBridgeSourceObservation.ts
 import { buildNextBlock as buildNextBlock4 } from "@xyo-network/chain-protocol";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { BridgeSourceObservationSchema } from "@xyo-network/xl1-protocol";
 var getBridgeSourceObservation = /* @__PURE__ */ __name(async (previousBlock, account, chainService) => {
   const srcTxHash = previousBlock[0]._hash;
   const bridgeSourceObservationFields = {
-    ...getBridgeSourceDetails(account, chainService),
+    ...await getBridgeSourceDetails(account, chainService),
     ...getBridgeDestinationDetails(),
     // Observation
     srcConfirmation: srcTxHash
   };
-  const bridgeSourceObservation = new PayloadBuilder6({
+  const bridgeSourceObservation = new PayloadBuilder5({
     schema: BridgeSourceObservationSchema
   }).fields(bridgeSourceObservationFields).build();
   return await buildNextBlock4(previousBlock[0], [], [
@@ -1299,7 +1187,7 @@ import { buildBlock } from "@xyo-network/chain-protocol";
 import { AttoXL1, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
 var getFirstBlockForNewChain = /* @__PURE__ */ __name(async (forkBlock, account, chainService) => {
   const { _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes = [], protocol } = forkBlock;
-  const chainId = chainService.chainId;
+  const chainId = await chainService.chainId();
   const options = {
     blockPayloads: [],
     chainId,
@@ -1332,14 +1220,14 @@ var createForkedHead = /* @__PURE__ */ __name(async (forkFromBlock, account, cha
 }, "createForkedHead");
 
 // src/orchestration/services/implementation/head/getForkFromBlock.ts
-import { asHash, hexFromBigInt, isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { asHash, hexFromBigInt, isDefined as isDefined14 } from "@xylabs/sdk-js";
 import { isSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
 var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainArchivist) => {
-  if (head.chain !== chainService.chainId) {
+  if (head.chain !== await chainService.chainId()) {
     const forkedAtBigInt = await chainService.forkedAtHash();
     const forkedAtHex = hexFromBigInt(forkedAtBigInt);
     const forkedAtHash = asHash(forkedAtHex);
-    if (isDefined12(forkedAtHash)) {
+    if (isDefined14(forkedAtHash)) {
       const [forkedAtBlock] = await chainArchivist.get([
         forkedAtHash
       ]);
@@ -1374,19 +1262,19 @@ var headSingleton;
 var initHead = /* @__PURE__ */ __name(async (params) => {
   const { account, chainArchivist, chainSubmissionsArchivistWrite, chainService } = params;
   if (headSingleton) return headSingleton;
-  let head = await findMostRecentBlock2(chainArchivist);
+  let head = await findMostRecentBlock(chainArchivist);
   if (head) {
     const forkFromBlock = await getForkFromBlock(head, chainService, chainArchivist);
-    if (isDefined13(forkFromBlock)) {
+    if (isDefined15(forkFromBlock)) {
       const chain = await createForkedHead(forkFromBlock, account, chainService);
       await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
-      const newBlock = assertEx17(chain.at(-1), () => new Error("Failed to get new head after forking"));
+      const newBlock = assertEx15(chain.at(-1), () => new Error("Failed to get new head after forking"));
       head = newBlock[0];
     }
   } else {
     const chain = await createBootstrapHead(account, chainService);
     await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
-    const newBlock = assertEx17(chain.at(-1), () => new Error("Failed to get new head after genesis"));
+    const newBlock = assertEx15(chain.at(-1), () => new Error("Failed to get new head after genesis"));
     head = newBlock[0];
   }
   headSingleton = head;
@@ -1394,37 +1282,49 @@ var initHead = /* @__PURE__ */ __name(async (params) => {
 }, "initHead");
 
 // src/orchestration/services/implementation/pendingTransactions.ts
+import { isDefined as isDefined16 } from "@xylabs/sdk-js";
 import { BasePendingTransactionsService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget9 } from "@xyo-network/xl1-protocol-sdk";
+import { timeBudget as timeBudget7 } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcTransport as HttpRpcTransport3, JsonRpcMempoolViewer, MempoolViewerRpcSchemas } from "@xyo-network/xl1-rpc";
 var serviceSingleton;
-var initPendingTransactions = /* @__PURE__ */ __name(async (params) => {
+var initPendingTransactions = /* @__PURE__ */ __name(async ({ config: config2, params, logger }) => {
   if (serviceSingleton) return serviceSingleton;
-  return await timeBudget9("initPendingTransactions", params.logger, async () => {
-    serviceSingleton = await BasePendingTransactionsService.create(params);
+  return await timeBudget7("initPendingTransactions", logger, async () => {
+    const endpoint = config2.services?.apiEndpoint;
+    if (isDefined16(endpoint)) {
+      const transport = new HttpRpcTransport3(endpoint, {
+        ...MempoolViewerRpcSchemas
+      });
+      const viewer = new JsonRpcMempoolViewer(transport);
+      logger?.log("Using MempoolViewer RPC service at", endpoint);
+      return viewer;
+    } else {
+      serviceSingleton = await BasePendingTransactionsService.create(params);
+    }
     return serviceSingleton;
   }, 2e3, true);
 }, "initPendingTransactions");
 
 // src/orchestration/services/implementation/producer.ts
 import { BaseBlockProducerService as BaseBlockProducerService2 } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget10 } from "@xyo-network/xl1-protocol-sdk";
+import { timeBudget as timeBudget8 } from "@xyo-network/xl1-protocol-sdk";
 var serviceSingleton2;
 var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
   if (serviceSingleton2) return serviceSingleton2;
-  return await timeBudget10("initBlockProducer", params.logger, async () => {
+  return await timeBudget8("initBlockProducer", params.logger, async () => {
     serviceSingleton2 = await BaseBlockProducerService2.create(params);
     return serviceSingleton2;
   }, 2e3, true);
 }, "initBlockProducer");
 
 // src/orchestration/services/implementation/reward.ts
-import { assertEx as assertEx18 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
 import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget11 } from "@xyo-network/xl1-protocol-sdk";
+import { timeBudget as timeBudget9 } from "@xyo-network/xl1-protocol-sdk";
 var rewardServiceSingleton;
 var initBlockRewardService = /* @__PURE__ */ __name((params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
-  return timeBudget11("initBlockRewardService", params.logger, () => {
+  return timeBudget9("initBlockRewardService", params.logger, () => {
     const { config: config2 } = params;
     rewardServiceSingleton = canUseEvmBlockRewardService({
       config: config2
@@ -1434,7 +1334,7 @@ var initBlockRewardService = /* @__PURE__ */ __name((params) => {
 }, "initBlockRewardService");
 var initXyoBlockRewardService = /* @__PURE__ */ __name((params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
-  return timeBudget11("initXyoBlockRewardService", params.logger, () => {
+  return timeBudget9("initXyoBlockRewardService", params.logger, () => {
     rewardServiceSingleton = MemoryBlockRewardService.create(params);
     return rewardServiceSingleton;
   }, 2e3, true);
@@ -1444,10 +1344,10 @@ var canUseEvmBlockRewardService = /* @__PURE__ */ __name((params) => canUseEvmPr
 }), "canUseEvmBlockRewardService");
 var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
-  return await timeBudget11("initEvmBlockRewardService", params.logger, async () => {
+  return await timeBudget9("initEvmBlockRewardService", params.logger, async () => {
     const { account: paramsAccount } = params;
-    const account = assertEx18(paramsAccount, () => "Account is required");
-    const provider2 = assertEx18(await initEvmProvider(params));
+    const account = assertEx16(paramsAccount, () => "Account is required");
+    const provider2 = assertEx16(await initEvmProvider(params));
     const evmBlockRewardServiceParams = {
       ...params,
       provider: provider2,
@@ -1460,19 +1360,18 @@ var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
 
 // src/orchestration/services/implementation/time.ts
 import { BaseTimeSyncService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget12 } from "@xyo-network/xl1-protocol-sdk";
+import { timeBudget as timeBudget10 } from "@xyo-network/xl1-protocol-sdk";
 var timeSyncServiceSingleton;
-var initTimeService = /* @__PURE__ */ __name(async ({ chainArchivist, chainIterator, config: config2, logger, meterProvider, traceProvider }) => {
+var initTimeService = /* @__PURE__ */ __name(async ({ blockViewer, config: config2, logger, meterProvider, traceProvider }) => {
   if (timeSyncServiceSingleton) return timeSyncServiceSingleton;
-  return await timeBudget12("initTimeService", logger, async () => {
+  return await timeBudget10("initTimeService", logger, async () => {
     const ethProvider = canUseEvmProvider({
       config: config2
     }) ? await initEvmProvider({
       config: config2
     }) : void 0;
     timeSyncServiceSingleton = BaseTimeSyncService.create({
-      chainArchivist,
-      chainIterator,
+      blockViewer,
       ethProvider,
       logger,
       meterProvider,
@@ -1484,11 +1383,11 @@ var initTimeService = /* @__PURE__ */ __name(async ({ chainArchivist, chainItera
 
 // src/orchestration/services/implementation/transfer.ts
 import { BaseAccountTransfersService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget13 } from "@xyo-network/xl1-protocol-sdk";
+import { timeBudget as timeBudget11 } from "@xyo-network/xl1-protocol-sdk";
 var transferServiceSingleton;
 var initTransferService = /* @__PURE__ */ __name(async (params) => {
   if (transferServiceSingleton) return transferServiceSingleton;
-  return await timeBudget13("initTransferService", params.logger, async () => {
+  return await timeBudget11("initTransferService", params.logger, async () => {
     transferServiceSingleton = await BaseAccountTransfersService.create(params);
     return transferServiceSingleton;
   }, 2e3, true);
@@ -1595,7 +1494,7 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 // src/orchestration/initServices.ts
 var isStartable = /* @__PURE__ */ __name((value) => {
   const possibleStartable = value;
-  return isDefined14(possibleStartable.start) && typeof possibleStartable.start === "function" && possibleStartable.status === "created";
+  return isDefined17(possibleStartable.start) && typeof possibleStartable.start === "function" && possibleStartable.status === "created";
 }, "isStartable");
 var initServices = /* @__PURE__ */ __name(async (context) => {
   const { config: config2, logger } = context;
@@ -1611,7 +1510,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     logger.error("Producer encountered an unhandled error!");
     process.exit(1);
   });
-  await startupSpanAsync8("initHealthEndpoints", () => initHealthEndpoints({
+  await startupSpanAsync7("initHealthEndpoints", () => initHealthEndpoints({
     ...context,
     statusReporter
   }));
@@ -1629,8 +1528,8 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     }
   };
   const [{ traceProvider, meterProvider }, account] = await Promise.all([
-    startupSpanAsync8("initTelemetry", () => initTelemetry(telemetryConfig)),
-    startupSpanAsync8("initProducerAccount", () => initProducerAccount(context))
+    startupSpanAsync7("initTelemetry", () => initTelemetry(telemetryConfig)),
+    startupSpanAsync7("initProducerAccount", () => initProducerAccount(context))
   ]);
   const allowedRewardRedeemers = config2.validation?.allowedRewardRedeemers ?? [];
   const allowedRewardEscrowAccountSigners = config2.validation?.allowedRewardEscrowAccountSigners ?? [];
@@ -1646,32 +1545,23 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     statusReporter,
     traceProvider
   };
-  const [chainArchivist, [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite], rejectedTransactionsArchivist, chainSubmissionsArchivistWrite, stakeIntentStateArchivist, chainService, balanceSummaryMap, transferSummaryMap] = await Promise.all([
-    startupSpanAsync8("ChainFinalizedArchivist", () => initChainFinalizedArchivist(initParams)),
-    startupSpanAsync8("PendingBundledTransactionsArchivist", () => initPendingBundledTransactionsArchivist(initParams)),
-    startupSpanAsync8("RejectedTransactionsArchivist", () => initRejectedTransactionsArchivist(initParams)),
-    startupSpanAsync8("ChainSubmissionsArchivist", () => initChainSubmissionsArchivist(initParams)),
-    startupSpanAsync8("StakeIntentStateArchivist", () => initStakeIntentStateArchivist(initParams)),
-    startupSpanAsync8("ChainService", () => initChainService({
+  const [[pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite], rejectedTransactionsArchivist, chainSubmissionsArchivistWrite, stakeIntentStateArchivist, chainService, balanceSummaryMap] = await Promise.all([
+    startupSpanAsync7("PendingBundledTransactionsArchivist", () => initPendingBundledTransactionsArchivist(initParams)),
+    startupSpanAsync7("RejectedTransactionsArchivist", () => initRejectedTransactionsArchivist(initParams)),
+    startupSpanAsync7("ChainSubmissionsArchivist", () => initChainSubmissionsArchivist(initParams)),
+    startupSpanAsync7("StakeIntentStateArchivist", () => initStakeIntentStateArchivist(initParams)),
+    startupSpanAsync7("ChainService", () => initChainService({
       ...initParams,
       account,
       name: "ChainService"
     })),
-    startupSpanAsync8("BalanceSummaryMap", () => initBalanceSummaryMap(initParams)),
-    startupSpanAsync8("TransferSummaryMap", () => initTransferSummaryMap(initParams))
+    startupSpanAsync7("BalanceSummaryMap", () => initBalanceSummaryMap(initParams)),
+    startupSpanAsync7("TransferSummaryMap", () => initTransferSummaryMap(initParams))
   ]);
-  const chainId = chainService.chainId;
-  const chainMap = readPayloadMapFromStore(chainArchivist);
+  const chainId = await chainService.chainId();
   const chainContractViewer = chainService;
   const chainStakeViewer = chainService;
   const chainStaker = chainService;
-  const head = await startupSpanAsync8("initHead", () => initHead({
-    ...initParams,
-    account,
-    chainArchivist,
-    chainSubmissionsArchivistWrite,
-    chainService
-  }));
   const additionalPendingTransactionValidators = [
     TransactionTransfersValidatorFactory([
       SelfSignerValidator,
@@ -1679,98 +1569,48 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
       DerivedReceiveAddressValidatorFactory(allowedRewardEscrowAccountSigners, "reward-escrow")
     ])
   ];
-  const [pendingTransactionsService, rewardService, chainIterator] = await Promise.all([
-    startupSpanAsync8("PendingTransactions", () => initPendingTransactions({
-      name: "PendingTransactionsService",
-      chainArchivist,
-      chainId,
-      pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-      additionalPendingTransactionValidators,
-      ...initParams
+  const [pendingTransactionsService, rewardService] = await Promise.all([
+    startupSpanAsync7("PendingTransactions", () => initPendingTransactions({
+      config: config2,
+      params: {
+        name: "PendingTransactionsService",
+        chainId,
+        pendingBundledTransactionsArchivist,
+        rejectedTransactionsArchivist,
+        additionalPendingTransactionValidators,
+        ...initParams
+      }
     })),
-    startupSpanAsync8("RewardService", () => initBlockRewardService({
+    startupSpanAsync7("RewardService", () => initBlockRewardService({
       name: "RewardService",
       account,
       chainService,
       ...initParams
-    })),
-    startupSpanAsync8("ChainIterator", () => initChainIterator({
-      name: "ChainIterator",
-      chainMap,
-      head,
-      ...initParams
-    }))
-  ]);
-  const blockViewer = blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist);
-  const balanceContext = {
-    stepSemaphores: StepSizes.map(() => new Semaphore2(20)),
-    store: {
-      chainMap
-    },
-    head: /* @__PURE__ */ __name(async () => {
-      const head2 = await chainIterator.head();
-      return [
-        head2._hash,
-        head2.block
-      ];
-    }, "head"),
-    chainId,
-    summaryMap: balanceSummaryMap
-  };
-  const transferContext = {
-    stepSemaphores: StepSizes.map(() => new Semaphore2(20)),
-    store: {
-      chainMap
-    },
-    head: /* @__PURE__ */ __name(async () => {
-      const head2 = await chainIterator.head();
-      return [
-        head2._hash,
-        head2.block
-      ];
-    }, "head"),
-    chainId,
-    summaryMap: transferSummaryMap
-  };
-  const [balanceService] = await Promise.all([
-    startupSpanAsync8("BalanceService", () => initAccountBalanceService({
-      params: {
-        name: "BalanceService",
-        config: {},
-        context: balanceContext,
-        blockViewer,
-        chainArchivist,
-        chainIterator,
-        transferContext
-      },
-      ...initParams
-    })),
-    startupSpanAsync8("TransferService", () => initTransferService({
-      name: "TransferService",
-      context: transferContext,
-      ...initParams
     }))
   ]);
+  const blockViewer = await startupSpanAsync7("BlockViewer", () => initBlockViewer({
+    ...initParams
+  }));
+  const balanceService = await startupSpanAsync7("BalanceService", () => initAccountBalanceService({
+    ...initParams
+  }));
   const [stakeIntentService, time] = await Promise.all([
-    startupSpanAsync8("StakeIntentService", () => initStakeIntentService({
+    startupSpanAsync7("StakeIntentService", () => initStakeIntentService({
       name: "StakeIntentService",
-      chainArchivist,
-      chainIterator,
+      blockViewer,
       chainStakeViewer,
       stakeIntentStateArchivist,
       ...initParams
     })),
-    startupSpanAsync8("TimeService", () => initTimeService({
+    startupSpanAsync7("TimeService", () => initTimeService({
       name: "TimeService",
-      chainArchivist,
-      chainIterator,
+      blockViewer,
       ...initParams
     }))
   ]);
-  const electionService = await startupSpanAsync8("ElectionService", () => initElectionService({
+  const electionService = await startupSpanAsync7("ElectionService", () => initElectionService({
     name: "ElectionService",
-    chainIterator,
+    blockViewer,
     chainStakeViewer,
     stakeIntentService,
     ...initParams
@@ -1780,19 +1620,19 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     account,
     chainId,
     pendingBundledTransactionsArchivist,
-    chainArchivist,
+    blockViewer,
     electionService,
     rewardService,
     stakeIntentService,
     validateHydratedBlockState,
     ...initParams
   };
-  const rewardAddress = isDefined14(config2.producer.rewardAddress) ? assertEx19(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
+  const rewardAddress = isDefined17(config2.producer.rewardAddress) ? assertEx17(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
   const producerParams = {
     ...validatorParams,
     name: "Producer",
     balanceService,
-    chainArchivist,
+    blockViewer,
     pendingBundledTransactionsArchivist,
     pendingTransactionsService,
     rejectedTransactionsArchivist,
@@ -1800,13 +1640,12 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     time,
     ...initParams
   };
-  const producer = await startupSpanAsync8("Producer", () => initBlockProducer(producerParams));
+  const producer = await startupSpanAsync7("Producer", () => initBlockProducer(producerParams));
   const services = {
     account,
     balance: balanceService,
-    chainArchivist,
     chainContractViewer,
-    chainIterator,
+    blockViewer,
     chainStaker,
     chainStakeViewer,
     chainSubmissionsArchivistWrite,
@@ -1822,7 +1661,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     balanceSummaryMap,
     ...Object.values(services)
   ].filter(isStartable);
-  assertEx19((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
+  assertEx17((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
   logger?.log("All services started successfully.");
   return {
     ...services,
@@ -1831,7 +1670,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
 }, "initServices");
 
 // src/runCLI.ts
-import { deepMerge, isDefined as isDefined17 } from "@xylabs/sdk-js";
+import { deepMerge, isDefined as isDefined21 } from "@xylabs/sdk-js";
 import { ConfigZod } from "@xyo-network/xl1-protocol-sdk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -1859,6 +1698,7 @@ function runMempool(context) {
 __name(runMempool, "runMempool");
 
 // src/commands/producer/runProducer.ts
+import { exists, isDefined as isDefined18 } from "@xylabs/sdk-js";
 var runProducer = /* @__PURE__ */ __name(async (context) => {
   const { config: config2, logger, orchestrator } = context;
   logger?.log("Services: Initializing...");
@@ -1868,11 +1708,8 @@ var runProducer = /* @__PURE__ */ __name(async (context) => {
     ...services,
     config: config2
   };
-  const chainHeadUpdate = await ChainHeadUpdateActor.create({
-    ...params,
-    name: "ChainHeadUpdateActor"
-  });
-  const balances = await BalanceActor.create({
+  const apiEndpoint = config2.services.apiEndpoint;
+  const balances = isDefined18(apiEndpoint) ? void 0 : await BalanceActor.create({
     ...params,
     name: "BalanceActor"
   });
@@ -1881,10 +1718,9 @@ var runProducer = /* @__PURE__ */ __name(async (context) => {
     name: "ProducerActor"
   });
   const actors = [
-    chainHeadUpdate,
     balances,
     producer
-  ];
+  ].filter(exists);
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
@@ -1919,16 +1755,16 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 \x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;108;93;162m\xB2\x1B[0m\x1B[38;2;99;79;176m^\x1B[0m`;
 
 // src/initLogger.ts
-import { Base as Base2, ConsoleLogger, isDefined as isDefined15, LogLevel, SilentLogger } from "@xylabs/sdk-js";
+import { Base as Base2, ConsoleLogger, isDefined as isDefined19, LogLevel, SilentLogger } from "@xylabs/sdk-js";
 var initLogger = /* @__PURE__ */ __name((config2) => {
   let logger;
   if (config2.silent) {
     logger = new SilentLogger();
   } else {
     let level;
-    if (isDefined15(config2.logLevel)) {
+    if (isDefined19(config2.logLevel)) {
       const parsed = LogLevel[config2.logLevel.toLowerCase()];
-      if (isDefined15(parsed)) level = parsed;
+      if (isDefined19(parsed)) level = parsed;
     }
     logger = new ConsoleLogger(level);
   }
@@ -1954,7 +1790,7 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
 }, "optionsFromGlobalZodRegistry");
 
 // src/tryParseConfig.ts
-import { isDefined as isDefined16, isNull } from "@xylabs/sdk-js";
+import { isDefined as isDefined20, isNull } from "@xylabs/sdk-js";
 import { cosmiconfigSync } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
@@ -1963,7 +1799,7 @@ var tryParseConfig = /* @__PURE__ */ __name(() => {
   const result = explorer.search();
   if (!isNull(result)) {
     const section = result?.config?.[configSection];
-    if (isDefined16(section) && typeof section === "object") {
+    if (isDefined20(section) && typeof section === "object") {
       return section;
     }
   }
@@ -1993,7 +1829,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined17("1.16.25") ? "1.16.25" : "unknown";
+var version = isDefined21("1.16.26") ? "1.16.26" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);
@@ -2119,7 +1955,6 @@ var start = /* @__PURE__ */ __name(async () => {
 export {
   Actor,
   BalanceActor,
-  ChainHeadUpdateActor,
   LoggerStatusReporter,
   Orchestrator,
   ProducerActor,
@@ -2129,6 +1964,7 @@ export {
   initAccountBalanceService,
   initBlockProducer,
   initBlockRewardService,
+  initBlockViewer,
   initChainService,
   initEvmProvider,
   initHead,