@xyo-network/xl1-providers 3.0.0 → 3.0.2

package/dist/browser/index.mjs

@@ -11,52 +11,269 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/buildProviderLocator.ts
+// src/buildSimpleXyoSignerV2.ts
+import { XyoSignerMoniker } from "@xyo-network/xl1-protocol-lib";
+import { ProviderFactoryLocator, SimpleXyoSigner } from "@xyo-network/xl1-protocol-sdk";
+async function buildSimpleXyoSignerV2(context, account) {
+  const locator = new ProviderFactoryLocator(context);
+  locator.register(
+    SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account })
+  );
+  return await locator.getInstance(XyoSignerMoniker);
+}
+
+// src/creators/createRestDataLake.ts
+import { RestDataLakeRunner as RestDataLakeRunner3, RestDataLakeViewer as RestDataLakeViewer4 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/locators/baseConfigFactoryLocator.ts
+import {
+  BaseConfigZod,
+  ProviderFactoryLocator as ProviderFactoryLocator2
+} from "@xyo-network/xl1-protocol-sdk";
+async function baseConfigFactoryLocator() {
+  const config = BaseConfigZod.parse({});
+  return new ProviderFactoryLocator2({
+    config,
+    singletons: {},
+    caches: {}
+  }, {});
+}
+
+// src/locators/basicRemoteRunnerLocator.ts
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import {
+  ProviderFactoryLocator as ProviderFactoryLocator4,
+  RestDataLakeRunner as RestDataLakeRunner2,
+  RestDataLakeViewer as RestDataLakeViewer3,
+  SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2
+} from "@xyo-network/xl1-protocol-sdk";
+import { JsonRpcXyoRunner as JsonRpcXyoRunner2, JsonRpcXyoSigner as JsonRpcXyoSigner2 } from "@xyo-network/xl1-rpc";
+
+// src/SimpleXyoConnectionRunner.ts
+import {
+  DataLakeRunnerMoniker,
+  DataLakeViewerMoniker,
+  XyoConnectionMoniker,
+  XyoRunnerMoniker,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-protocol-lib";
+import { AbstractCreatableProvider, creatableProvider } from "@xyo-network/xl1-protocol-sdk";
+var SimpleXyoConnectionRunner = class extends AbstractCreatableProvider {
+  moniker = SimpleXyoConnectionRunner.defaultMoniker;
+  _network;
+  _runner;
+  _storage;
+  _viewer;
+  get network() {
+    return this._network;
+  }
+  get runner() {
+    return this._runner;
+  }
+  get storage() {
+    return this._storage;
+  }
+  get viewer() {
+    return this._viewer;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._runner = await this.locator.getInstance(XyoRunnerMoniker);
+    this._viewer = await this.locator.getInstance(XyoViewerMoniker);
+    const dataLakeRunner = await this.locator.tryGetInstance(DataLakeRunnerMoniker);
+    const dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
+    this._storage = dataLakeRunner ?? dataLakeViewer;
+  }
+};
+__publicField(SimpleXyoConnectionRunner, "connectionTypes", []);
+__publicField(SimpleXyoConnectionRunner, "defaultMoniker", XyoConnectionMoniker);
+__publicField(SimpleXyoConnectionRunner, "dependencies", [XyoRunnerMoniker, XyoViewerMoniker]);
+__publicField(SimpleXyoConnectionRunner, "monikers", [XyoConnectionMoniker]);
+__publicField(SimpleXyoConnectionRunner, "surface", "node");
+SimpleXyoConnectionRunner = __decorateClass([
+  creatableProvider()
+], SimpleXyoConnectionRunner);
+
+// src/locators/basicRemoteViewerLocator.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import {
+  ActorConfigZod,
+  RestDataLakeViewer as RestDataLakeViewer2,
+  SimpleXyoGateway as SimpleXyoGateway2
+} from "@xyo-network/xl1-protocol-sdk";
+
+// src/SimpleXyoConnectionViewer.ts
+import {
+  DataLakeViewerMoniker as DataLakeViewerMoniker2,
+  XyoConnectionMoniker as XyoConnectionMoniker2,
+  XyoViewerMoniker as XyoViewerMoniker2
+} from "@xyo-network/xl1-protocol-lib";
+import { AbstractCreatableProvider as AbstractCreatableProvider2, creatableProvider as creatableProvider2 } from "@xyo-network/xl1-protocol-sdk";
+var SimpleXyoConnectionViewer = class extends AbstractCreatableProvider2 {
+  moniker = SimpleXyoConnectionViewer.defaultMoniker;
+  _network;
+  _storage;
+  _viewer;
+  get network() {
+    return this._network;
+  }
+  get storage() {
+    return this._storage;
+  }
+  get viewer() {
+    return this._viewer;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._viewer = await this.locator.getInstance(XyoViewerMoniker2);
+    const dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker2);
+    this._storage = dataLakeViewer;
+  }
+};
+__publicField(SimpleXyoConnectionViewer, "connectionTypes", []);
+__publicField(SimpleXyoConnectionViewer, "defaultMoniker", XyoConnectionMoniker2);
+__publicField(SimpleXyoConnectionViewer, "dependencies", [XyoViewerMoniker2]);
+__publicField(SimpleXyoConnectionViewer, "monikers", [XyoConnectionMoniker2]);
+__publicField(SimpleXyoConnectionViewer, "surface", "node");
+SimpleXyoConnectionViewer = __decorateClass([
+  creatableProvider2()
+], SimpleXyoConnectionViewer);
+
+// src/locators/remoteLocatorFromConfig.ts
+import {
+  adaptLegacyConfig as adaptLegacyConfig2,
+  needsFromConnectionTypes,
+  SimpleBlockValidationViewer as SimpleBlockValidationViewer2,
+  SimpleStakeEventsViewer as SimpleStakeEventsViewer2,
+  SimpleTransactionValidationViewer as SimpleTransactionValidationViewer2,
+  SimpleWindowedBlockViewer as SimpleWindowedBlockViewer2
+} from "@xyo-network/xl1-protocol-sdk";
+
+// src/locators/locatorFromAdaptedConfig.ts
 import {
-  ConfigZod,
-  getEmptyProviderContext,
-  ProviderFactoryLocator,
+  adaptLegacyConfig,
+  locatorFromConfig,
+  needsFromProviderBindings,
+  ProviderFactoryLocator as ProviderFactoryLocator3,
+  registerFactoriesFromPlan,
+  resolveProvidersFromConfig
+} from "@xyo-network/xl1-protocol-sdk";
+
+// src/locators/providerCandidates.ts
+import {
+  providerCandidatesFromClasses,
+  RestDataLakeRunner,
+  RestDataLakeViewer,
   SimpleAccountBalanceViewer,
+  SimpleBlockRewardViewer,
+  SimpleBlockValidationViewer,
   SimpleBlockViewer,
+  SimpleChainContractViewer,
+  SimpleFinalizationRunner,
   SimpleFinalizationViewer,
-  SimpleMempoolRunner,
+  SimpleMempoolRunner as SimpleMempoolRunner2,
   SimpleMempoolViewer,
-  SimpleStakeEventsViewer as SimpleStakeEventsViewer2,
-  SimpleStakeViewer as SimpleStakeViewer2,
+  SimpleStakeEventsViewer,
+  SimpleStakeTotalsViewer,
+  SimpleStakeViewer,
   SimpleTimeSyncViewer,
+  SimpleTransactionValidationViewer,
+  SimpleTransactionViewer,
   SimpleWindowedBlockViewer,
+  SimpleXyoGateway,
+  SimpleXyoGatewayRunner,
   SimpleXyoRunner
 } from "@xyo-network/xl1-protocol-sdk";
 import {
-  AccountBalanceViewerRpcSchemas,
-  BlockViewerRpcSchemas,
   JsonRpcAccountBalanceViewer,
   JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
   JsonRpcMempoolRunner,
   JsonRpcMempoolViewer,
-  JsonRpcNetworkStakeStepRewardsViewer,
   JsonRpcNetworkStakeViewer,
   JsonRpcStakeTotalsViewer,
+  JsonRpcStakeViewer,
   JsonRpcTimeSyncViewer,
+  JsonRpcTransactionViewer,
   JsonRpcXyoRunner,
-  JsonRpcXyoViewer,
-  MempoolRunnerRpcSchemas,
-  MempoolViewerRpcSchemas,
-  NetworkStakeViewerRpcSchemas,
-  StakeTotalsViewerRpcSchemas,
-  TimeSyncViewerRpcSchemas,
-  XyoRunnerRpcSchemas,
-  XyoViewerRpcSchemas
+  JsonRpcXyoSigner,
+  JsonRpcXyoViewer
 } from "@xyo-network/xl1-rpc";
 
+// src/NodeXyoRunner.ts
+import { assertEx } from "@xylabs/sdk-js";
+import { asArchivistInstance } from "@xyo-network/sdk-js";
+import { XyoRunnerMoniker as XyoRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider3,
+  creatableProvider as creatableProvider3,
+  SimpleMempoolRunner
+} from "@xyo-network/xl1-protocol-sdk";
+var NodeXyoRunner = class extends AbstractCreatableProvider3 {
+  moniker = NodeXyoRunner.defaultMoniker;
+  _mempoolRunner;
+  _pendingBlocksArchivist;
+  _pendingTransactionsArchivist;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  get node() {
+    return this.params.node;
+  }
+  get pendingBlocksArchivist() {
+    return this._pendingBlocksArchivist;
+  }
+  get pendingBlocksArchivistPath() {
+    return this.params.pendingBlocksArchivistPath ?? "XYOChain:Pending:Blocks";
+  }
+  get pendingTransactionsArchivist() {
+    return this._pendingTransactionsArchivist;
+  }
+  get pendingTransactionsArchivistPath() {
+    return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
+  }
+  async broadcastTransaction(transaction) {
+    const [txHash] = await this.mempool.submitTransactions([transaction]);
+    return txHash;
+  }
+  getArchivist = async (identifier) => {
+    const archivist = await this.node.resolve(identifier);
+    return assertEx(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
+  };
+  async startHandler() {
+    await super.startHandler();
+    this._pendingTransactionsArchivist = assertEx(
+      await this.getArchivist(this.pendingTransactionsArchivistPath),
+      () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`
+    );
+    this._pendingBlocksArchivist = assertEx(
+      await this.getArchivist(this.pendingBlocksArchivistPath),
+      () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`
+    );
+    this._mempoolRunner = assertEx(await SimpleMempoolRunner.create({
+      context: this.context,
+      pendingTransactionsArchivist: this.pendingTransactionsArchivist,
+      pendingBlocksArchivist: this.pendingBlocksArchivist
+    }), () => "Failed to create SimpleMempoolRunner");
+  }
+};
+__publicField(NodeXyoRunner, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(NodeXyoRunner, "defaultMoniker", XyoRunnerMoniker2);
+__publicField(NodeXyoRunner, "dependencies", []);
+__publicField(NodeXyoRunner, "monikers", [XyoRunnerMoniker2]);
+__publicField(NodeXyoRunner, "surface", "node");
+NodeXyoRunner = __decorateClass([
+  creatableProvider3()
+], NodeXyoRunner);
+
 // src/NodeXyoViewer.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/sdk-js";
-import { creatableProvider as creatableProvider2 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider5 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/SimpleXyoViewer.ts
 import {
-  assertEx,
+  assertEx as assertEx2,
   toAddress
 } from "@xylabs/sdk-js";
 import {
@@ -75,13 +292,13 @@ import {
   TransactionViewerMoniker,
   XYO_NETWORK_STAKING_ADDRESS,
   XYO_ZERO_ADDRESS,
-  XyoViewerMoniker
+  XyoViewerMoniker as XyoViewerMoniker3
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider,
+  AbstractCreatableProvider as AbstractCreatableProvider4,
   allStakersForStep,
   blockRangeSteps,
-  creatableProvider,
+  creatableProvider as creatableProvider4,
   externalBlockRangeFromStep,
   externalBlockRangeFromXL1BlockRange,
   networkStakeStepRewardPositionWeight,
@@ -90,7 +307,7 @@ import {
   weightedStakeForRangeByPosition,
   withContextCacheResponse
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleXyoViewer = class extends AbstractCreatableProvider {
+var SimpleXyoViewer = class extends AbstractCreatableProvider4 {
   moniker = SimpleXyoViewer.defaultMoniker;
   _tracer;
   _accountBalanceViewer;
@@ -172,7 +389,7 @@ var SimpleXyoViewer = class extends AbstractCreatableProvider {
   }
   async chainId(blockNumber = "latest") {
     return await this.spanAsync("SimpleXyoViewer:chainId", async () => {
-      const chainId = assertEx(
+      const chainId = assertEx2(
         blockNumber === "latest" ? this._chainId : await this.chainContractViewer.chainIdAtBlockNumber(blockNumber),
         () => `Could not find block for chainId at block ${blockNumber}`
       );
@@ -408,7 +625,8 @@ var SimpleXyoViewer = class extends AbstractCreatableProvider {
     });
   }
 };
-__publicField(SimpleXyoViewer, "defaultMoniker", XyoViewerMoniker);
+__publicField(SimpleXyoViewer, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleXyoViewer, "defaultMoniker", XyoViewerMoniker3);
 __publicField(SimpleXyoViewer, "dependencies", [
   AccountBalanceViewerMoniker,
   BlockViewerMoniker,
@@ -420,9 +638,10 @@ __publicField(SimpleXyoViewer, "dependencies", [
   StepViewerMoniker,
   TimeSyncViewerMoniker
 ]);
-__publicField(SimpleXyoViewer, "monikers", [XyoViewerMoniker]);
+__publicField(SimpleXyoViewer, "monikers", [XyoViewerMoniker3]);
+__publicField(SimpleXyoViewer, "surface", "node");
 SimpleXyoViewer = __decorateClass([
-  creatableProvider()
+  creatableProvider4()
 ], SimpleXyoViewer);
 
 // src/NodeXyoViewer.ts
@@ -432,104 +651,203 @@ var NodeXyoViewer = class extends SimpleXyoViewer {
   }
   static async getFinalizedArchivistFromNode(node) {
     const resolved = await this.getArchivist(node, this.finalizedArchivistPath);
-    return assertEx2(resolved, () => `Could not resolve finalized archivist at ${this.finalizedArchivistPath}`);
+    return assertEx3(resolved, () => `Could not resolve finalized archivist at ${this.finalizedArchivistPath}`);
   }
 };
 __publicField(NodeXyoViewer, "finalizedArchivistPath", "XYOChain:Chain:Finalized");
 __publicField(NodeXyoViewer, "getArchivist", async (node, identifier) => {
   const archivist = await node.resolve(identifier);
-  return assertEx2(asAttachableArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
+  return assertEx3(asAttachableArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
 });
 NodeXyoViewer = __decorateClass([
-  creatableProvider2()
+  creatableProvider5()
 ], NodeXyoViewer);
 
-// src/registerHelpers.ts
-import {
-  SimpleStakeEventsViewer,
-  SimpleStakeViewer,
-  SimpleXyoGateway,
-  SimpleXyoGatewayRunner,
-  SimpleXyoSigner
-} from "@xyo-network/xl1-protocol-sdk";
-
-// src/SimpleXyoConnectionRunner.ts
+// src/SimpleDeadLetterQueueRunner.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { isHashMeta, PayloadBuilder } from "@xyo-network/sdk-js";
 import {
-  DataLakeRunnerMoniker,
-  DataLakeViewerMoniker,
-  XyoConnectionMoniker,
-  XyoRunnerMoniker,
-  XyoViewerMoniker as XyoViewerMoniker2
+  DeadLetterQueueRunnerMoniker,
+  isBlockRejection,
+  isTransactionRejection
 } from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider2, creatableProvider as creatableProvider3 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleXyoConnectionRunner = class extends AbstractCreatableProvider2 {
-  moniker = SimpleXyoConnectionRunner.defaultMoniker;
-  _network;
-  _runner;
-  _storage;
-  _viewer;
-  get network() {
-    return this._network;
-  }
-  get runner() {
-    return this._runner;
-  }
-  get storage() {
-    return this._storage;
+import { AbstractCreatableProvider as AbstractCreatableProvider5, creatableProvider as creatableProvider6 } from "@xyo-network/xl1-protocol-sdk";
+var SimpleDeadLetterQueueRunner = class extends AbstractCreatableProvider5 {
+  moniker = SimpleDeadLetterQueueRunner.defaultMoniker;
+  get rejectedBlocksArchivist() {
+    return this.params.rejectedBlocksArchivist;
   }
-  get viewer() {
-    return this._viewer;
+  get rejectedTransactionsArchivist() {
+    return this.params.rejectedTransactionsArchivist;
   }
-  async createHandler() {
-    await super.createHandler();
-    this._runner = await this.locator.getInstance(XyoRunnerMoniker);
-    this._viewer = await this.locator.getInstance(XyoViewerMoniker2);
-    const dataLakeRunner = await this.locator.tryGetInstance(DataLakeRunnerMoniker);
-    const dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
-    this._storage = dataLakeRunner ?? dataLakeViewer;
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      rejectedBlocksArchivist: assertEx4(params?.rejectedBlocksArchivist, () => "rejectedBlocksArchivist is required"),
+      rejectedTransactionsArchivist: assertEx4(params?.rejectedTransactionsArchivist, () => "rejectedTransactionsArchivist is required")
+    };
   }
-};
-__publicField(SimpleXyoConnectionRunner, "defaultMoniker", XyoConnectionMoniker);
-__publicField(SimpleXyoConnectionRunner, "dependencies", [XyoRunnerMoniker, XyoViewerMoniker2]);
-__publicField(SimpleXyoConnectionRunner, "monikers", [XyoConnectionMoniker]);
-SimpleXyoConnectionRunner = __decorateClass([
-  creatableProvider3()
-], SimpleXyoConnectionRunner);
-
-// src/registerHelpers.ts
-var registerGatewayRunnerWithLocatorIfProvided = (locator, params) => {
-  const account = params?.signerAccount;
-  if (account) {
-    locator.registerMany([
-      SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account }),
-      SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
-    ]);
+  async pruneRejectedBlocks({
+    batchSize = 10,
+    maxPrune = 1e3,
+    maxCheck = 1e3
+  } = {}) {
+    let total = 0;
+    let pruned = 0;
+    let cursor;
+    let batch = await this.rejectedBlocksArchivist.next({
+      limit: batchSize,
+      cursor,
+      order: "desc"
+    });
+    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
+      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isBlockRejection(p)).map((p) => p._hash);
+      pruned += pruneHashes.length;
+      total += batch.length;
+      if (pruneHashes.length > 0) {
+        await this.rejectedBlocksArchivist.delete(pruneHashes);
+      }
+      const pruneSet = new Set(pruneHashes);
+      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
+      cursor = lastSurvivor?._sequence ?? cursor;
+      batch = await this.rejectedBlocksArchivist.next({
+        limit: batchSize,
+        cursor,
+        order: "desc"
+      });
+    }
+    return [pruned, total];
   }
-  return locator;
-};
-var registerGatewayWithLocator = (locator, account) => {
-  locator.registerMany([
-    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
-    SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {})
-  ]);
-  if (account) {
-    locator.registerMany([
-      SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account }),
-      SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
-    ]);
+  async pruneRejectedTransactions({
+    batchSize = 10,
+    maxPrune = 1e3,
+    maxCheck = 1e3
+  } = {}) {
+    let total = 0;
+    let pruned = 0;
+    let cursor;
+    let batch = await this.rejectedTransactionsArchivist.next({
+      limit: batchSize,
+      cursor,
+      order: "desc"
+    });
+    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
+      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isTransactionRejection(p)).map((p) => p._hash);
+      pruned += pruneHashes.length;
+      total += batch.length;
+      if (pruneHashes.length > 0) {
+        await this.rejectedTransactionsArchivist.delete(pruneHashes);
+      }
+      const pruneSet = new Set(pruneHashes);
+      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
+      cursor = lastSurvivor?._sequence ?? cursor;
+      batch = await this.rejectedTransactionsArchivist.next({
+        limit: batchSize,
+        cursor,
+        order: "desc"
+      });
+    }
+    return [pruned, total];
+  }
+  async rejectBlock(rejection) {
+    const withMeta = await PayloadBuilder.addHashMeta(rejection);
+    const inserted = await this.rejectedBlocksArchivist.insert([withMeta]);
+    return inserted.length > 0;
+  }
+  async rejectTransaction(rejection) {
+    const withMeta = await PayloadBuilder.addHashMeta(rejection);
+    const inserted = await this.rejectedTransactionsArchivist.insert([withMeta]);
+    return inserted.length > 0;
   }
-  return locator;
 };
-var registerSimpleStakeViewerWithLocator = (locator, positions) => {
-  locator.registerMany([
-    SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, { positions }),
-    SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, { positions })
-  ]);
-  return locator;
+__publicField(SimpleDeadLetterQueueRunner, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleDeadLetterQueueRunner, "defaultMoniker", DeadLetterQueueRunnerMoniker);
+__publicField(SimpleDeadLetterQueueRunner, "dependencies", []);
+__publicField(SimpleDeadLetterQueueRunner, "monikers", [DeadLetterQueueRunnerMoniker]);
+__publicField(SimpleDeadLetterQueueRunner, "surface", "node");
+SimpleDeadLetterQueueRunner = __decorateClass([
+  creatableProvider6()
+], SimpleDeadLetterQueueRunner);
+
+// src/SimpleDeadLetterQueueViewer.ts
+import {
+  exists,
+  isDefined,
+  isHash
+} from "@xylabs/sdk-js";
+import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk-js";
+import {
+  DeadLetterQueueViewerMoniker,
+  isBlockRejection as isBlockRejection2,
+  isTransactionRejection as isTransactionRejection2
+} from "@xyo-network/xl1-protocol-lib";
+import { AbstractCreatableProvider as AbstractCreatableProvider6, creatableProvider as creatableProvider7 } from "@xyo-network/xl1-protocol-sdk";
+var SimpleDeadLetterQueueViewer = class extends AbstractCreatableProvider6 {
+  moniker = SimpleDeadLetterQueueViewer.defaultMoniker;
+  get rejectedBlocksArchivist() {
+    return this.params.rejectedBlocksArchivist;
+  }
+  get rejectedTransactionsArchivist() {
+    return this.params.rejectedTransactionsArchivist;
+  }
+  async rejectedBlocks({
+    cursor: providedCursor,
+    limit = 100,
+    rejector
+  } = {}) {
+    let cursor;
+    if (isHash(providedCursor)) {
+      const [p] = await this.rejectedBlocksArchivist.get([providedCursor]);
+      if (isDefined(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const payloads = await this.rejectedBlocksArchivist.next({
+      order: "desc",
+      limit,
+      cursor
+    });
+    const rejections = payloads.filter(isHashMeta2).map((p) => isBlockRejection2(p) ? p : void 0).filter(exists);
+    if (rejector !== void 0) {
+      return rejections.filter((r) => r.rejector === rejector);
+    }
+    return rejections;
+  }
+  async rejectedTransactions({
+    cursor: providedCursor,
+    limit = 100,
+    rejector
+  } = {}) {
+    let cursor;
+    if (isHash(providedCursor)) {
+      const [p] = await this.rejectedTransactionsArchivist.get([providedCursor]);
+      if (isDefined(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const payloads = await this.rejectedTransactionsArchivist.next({
+      order: "desc",
+      limit,
+      cursor
+    });
+    const rejections = payloads.filter(isHashMeta2).map((p) => isTransactionRejection2(p) ? p : void 0).filter(exists);
+    if (rejector !== void 0) {
+      return rejections.filter((r) => r.rejector === rejector);
+    }
+    return rejections;
+  }
 };
+__publicField(SimpleDeadLetterQueueViewer, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleDeadLetterQueueViewer, "defaultMoniker", DeadLetterQueueViewerMoniker);
+__publicField(SimpleDeadLetterQueueViewer, "dependencies", []);
+__publicField(SimpleDeadLetterQueueViewer, "monikers", [DeadLetterQueueViewerMoniker]);
+__publicField(SimpleDeadLetterQueueViewer, "surface", "node");
+SimpleDeadLetterQueueViewer = __decorateClass([
+  creatableProvider7()
+], SimpleDeadLetterQueueViewer);
 
 // src/SimpleNetworkStakeViewer.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import {
   FinalizationViewerMoniker as FinalizationViewerMoniker2,
   NetworkStakeStepRewardsViewerMoniker,
@@ -538,17 +856,17 @@ import {
   StakeViewerMoniker as StakeViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider3,
-  creatableProvider as creatableProvider4
+  AbstractCreatableProvider as AbstractCreatableProvider7,
+  creatableProvider as creatableProvider8
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleNetworkStakeViewer = class extends AbstractCreatableProvider3 {
+var SimpleNetworkStakeViewer = class extends AbstractCreatableProvider7 {
   moniker = SimpleNetworkStakeViewer.defaultMoniker;
   _finalizationViewer;
   _stake;
   _stakeTotals;
   _stepRewardsViewer;
   get stepRewards() {
-    return assertEx3(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
+    return assertEx5(this._stepRewardsViewer, () => "Step rewards viewer not initialized");
   }
   get finalizationViewer() {
     return this._finalizationViewer;
@@ -574,11 +892,13 @@ var SimpleNetworkStakeViewer = class extends AbstractCreatableProvider3 {
     this._stepRewardsViewer = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker);
   }
 };
+__publicField(SimpleNetworkStakeViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker2);
 __publicField(SimpleNetworkStakeViewer, "dependencies", [NetworkStakeStepRewardsViewerMoniker]);
 __publicField(SimpleNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker2]);
+__publicField(SimpleNetworkStakeViewer, "surface", "node");
 SimpleNetworkStakeViewer = __decorateClass([
-  creatableProvider4()
+  creatableProvider8()
 ], SimpleNetworkStakeViewer);
 
 // src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
@@ -592,9 +912,9 @@ import {
   StakeViewerMoniker as StakeViewerMoniker3
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider4,
+  AbstractCreatableProvider as AbstractCreatableProvider8,
   blockRangeSteps as blockRangeSteps2,
-  creatableProvider as creatableProvider5
+  creatableProvider as creatableProvider9
 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/SimpleStepRewards/primitives/networkStakeStepRewardEarned.ts
@@ -683,7 +1003,7 @@ async function networkStakeStepRewardEarnedForStaker(context, blockViewer, stake
 }
 
 // src/SimpleStepRewards/SimpleStepRewardsByPositionViewer.ts
-var SimpleStepRewardsByPositionViewer = class extends AbstractCreatableProvider4 {
+var SimpleStepRewardsByPositionViewer = class extends AbstractCreatableProvider8 {
   moniker = SimpleStepRewardsByPositionViewer.defaultMoniker;
   _blockViewer;
   _finalizationViewer;
@@ -754,11 +1074,13 @@ var SimpleStepRewardsByPositionViewer = class extends AbstractCreatableProvider4
     return result;
   }
 };
+__publicField(SimpleStepRewardsByPositionViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepRewardsByPositionViewer, "defaultMoniker", NetworkStakeStepRewardsByPositionViewerMoniker2);
 __publicField(SimpleStepRewardsByPositionViewer, "dependencies", [BlockViewerMoniker2]);
 __publicField(SimpleStepRewardsByPositionViewer, "monikers", [NetworkStakeStepRewardsByPositionViewerMoniker2]);
+__publicField(SimpleStepRewardsByPositionViewer, "surface", "node");
 SimpleStepRewardsByPositionViewer = __decorateClass([
-  creatableProvider5()
+  creatableProvider9()
 ], SimpleStepRewardsByPositionViewer);
 
 // src/SimpleStepRewards/SimpleStepRewardsByStakerViewer.ts
@@ -772,11 +1094,11 @@ import {
   StakeViewerMoniker as StakeViewerMoniker4
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider5,
+  AbstractCreatableProvider as AbstractCreatableProvider9,
   blockRangeSteps as blockRangeSteps3,
-  creatableProvider as creatableProvider6
+  creatableProvider as creatableProvider10
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsByStakerViewer = class extends AbstractCreatableProvider5 {
+var SimpleStepRewardsByStakerViewer = class extends AbstractCreatableProvider9 {
   moniker = SimpleStepRewardsByStakerViewer.defaultMoniker;
   _blockViewer;
   _finalizationViewer;
@@ -844,11 +1166,13 @@ var SimpleStepRewardsByStakerViewer = class extends AbstractCreatableProvider5 {
     return result;
   }
 };
+__publicField(SimpleStepRewardsByStakerViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepRewardsByStakerViewer, "defaultMoniker", NetworkStakeStepRewardsByStakerViewerMoniker);
 __publicField(SimpleStepRewardsByStakerViewer, "dependencies", [BlockViewerMoniker3]);
 __publicField(SimpleStepRewardsByStakerViewer, "monikers", [NetworkStakeStepRewardsByStakerViewerMoniker]);
+__publicField(SimpleStepRewardsByStakerViewer, "surface", "node");
 SimpleStepRewardsByStakerViewer = __decorateClass([
-  creatableProvider6()
+  creatableProvider10()
 ], SimpleStepRewardsByStakerViewer);
 
 // src/SimpleStepRewards/SimpleStepRewardsByStepViewer.ts
@@ -861,12 +1185,12 @@ import {
   StakeViewerMoniker as StakeViewerMoniker5
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider6,
+  AbstractCreatableProvider as AbstractCreatableProvider10,
   blockRangeSteps as blockRangeSteps4,
-  creatableProvider as creatableProvider7,
+  creatableProvider as creatableProvider11,
   toStepIdentityString as toStepIdentityString3
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsByStepViewer = class extends AbstractCreatableProvider6 {
+var SimpleStepRewardsByStepViewer = class extends AbstractCreatableProvider10 {
   moniker = SimpleStepRewardsByStepViewer.defaultMoniker;
   _blockViewer;
   _finalizationViewer;
@@ -943,20 +1267,22 @@ var SimpleStepRewardsByStepViewer = class extends AbstractCreatableProvider6 {
     throw new Error("Method  [unclaimed] ot implemented.");
   }
 };
+__publicField(SimpleStepRewardsByStepViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepRewardsByStepViewer, "defaultMoniker", NetworkStakeStepRewardsByStepViewerMoniker);
 __publicField(SimpleStepRewardsByStepViewer, "dependencies", [BlockViewerMoniker4]);
 __publicField(SimpleStepRewardsByStepViewer, "monikers", [NetworkStakeStepRewardsByStepViewerMoniker]);
+__publicField(SimpleStepRewardsByStepViewer, "surface", "node");
 SimpleStepRewardsByStepViewer = __decorateClass([
-  creatableProvider7()
+  creatableProvider11()
 ], SimpleStepRewardsByStepViewer);
 
 // src/SimpleStepRewards/SimpleStepRewardsTotalViewer.ts
 import { asAttoXL1 as asAttoXL15, NetworkStakeStepRewardsTotalViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider7,
-  creatableProvider as creatableProvider8
+  AbstractCreatableProvider as AbstractCreatableProvider11,
+  creatableProvider as creatableProvider12
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsTotalViewer = class extends AbstractCreatableProvider7 {
+var SimpleStepRewardsTotalViewer = class extends AbstractCreatableProvider11 {
   moniker = SimpleStepRewardsTotalViewer.defaultMoniker;
   get rewardMultipliers() {
     return this.params.rewardMultipliers ?? {};
@@ -982,15 +1308,17 @@ var SimpleStepRewardsTotalViewer = class extends AbstractCreatableProvider7 {
     throw new Error("Method  [calculateRewards] not implemented.");
   }
 };
+__publicField(SimpleStepRewardsTotalViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepRewardsTotalViewer, "defaultMoniker", NetworkStakeStepRewardsTotalViewerMoniker);
 __publicField(SimpleStepRewardsTotalViewer, "dependencies", []);
 __publicField(SimpleStepRewardsTotalViewer, "monikers", [NetworkStakeStepRewardsTotalViewerMoniker]);
+__publicField(SimpleStepRewardsTotalViewer, "surface", "node");
 SimpleStepRewardsTotalViewer = __decorateClass([
-  creatableProvider8()
+  creatableProvider12()
 ], SimpleStepRewardsTotalViewer);
 
 // src/SimpleStepRewards/SimpleStepRewardsViewer.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 import {
   BlockViewerMoniker as BlockViewerMoniker5,
   NetworkStakeStepRewardsByPositionViewerMoniker as NetworkStakeStepRewardsByPositionViewerMoniker3,
@@ -999,23 +1327,23 @@ import {
   NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider8,
-  creatableProvider as creatableProvider9
+  AbstractCreatableProvider as AbstractCreatableProvider12,
+  creatableProvider as creatableProvider13
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepRewardsViewer = class extends AbstractCreatableProvider8 {
+var SimpleStepRewardsViewer = class extends AbstractCreatableProvider12 {
   moniker = SimpleStepRewardsViewer.defaultMoniker;
   _blockViewer;
   _position;
   _staker;
   _step;
   get position() {
-    return assertEx4(this._position, () => "Position viewer not initialized");
+    return assertEx6(this._position, () => "Position viewer not initialized");
   }
   get staker() {
-    return assertEx4(this._staker, () => "Position viewer not initialized");
+    return assertEx6(this._staker, () => "Position viewer not initialized");
   }
   get step() {
-    return assertEx4(this._step, () => "Step viewer not initialized");
+    return assertEx6(this._step, () => "Step viewer not initialized");
   }
   get total() {
     throw new Error("Method [total] not implemented.");
@@ -1032,11 +1360,12 @@ var SimpleStepRewardsViewer = class extends AbstractCreatableProvider8 {
   }
   async startHandler() {
     await super.startHandler();
-    await assertEx4(this._position, () => "Position viewer not created").start();
-    await assertEx4(this._staker, () => "Staker viewer not created").start();
-    await assertEx4(this._step, () => "Step viewer not created").start();
+    await assertEx6(this._position, () => "Position viewer not created").start();
+    await assertEx6(this._staker, () => "Staker viewer not created").start();
+    await assertEx6(this._step, () => "Step viewer not created").start();
   }
 };
+__publicField(SimpleStepRewardsViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
 __publicField(SimpleStepRewardsViewer, "dependencies", [
   BlockViewerMoniker5,
@@ -1045,8 +1374,9 @@ __publicField(SimpleStepRewardsViewer, "dependencies", [
   NetworkStakeStepRewardsByStepViewerMoniker2
 ]);
 __publicField(SimpleStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
+__publicField(SimpleStepRewardsViewer, "surface", "node");
 SimpleStepRewardsViewer = __decorateClass([
-  creatableProvider9()
+  creatableProvider13()
 ], SimpleStepRewardsViewer);
 
 // src/SimpleStepViewer.ts
@@ -1058,11 +1388,11 @@ import {
   StepViewerMoniker as StepViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider9,
-  creatableProvider as creatableProvider10,
+  AbstractCreatableProvider as AbstractCreatableProvider13,
+  creatableProvider as creatableProvider14,
   externalBlockRangeFromStep as externalBlockRangeFromStep3
 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleStepViewer = class extends AbstractCreatableProvider9 {
+var SimpleStepViewer = class extends AbstractCreatableProvider13 {
   moniker = SimpleStepViewer.defaultMoniker;
   _blockViewer;
   _networkStakeStepRewardsViewer;
@@ -1115,6 +1445,7 @@ var SimpleStepViewer = class extends AbstractCreatableProvider9 {
     throw new Error("Method [weight] not implemented.");
   }
 };
+__publicField(SimpleStepViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleStepViewer, "defaultMoniker", StepViewerMoniker2);
 __publicField(SimpleStepViewer, "dependencies", [
   BlockViewerMoniker6,
@@ -1123,348 +1454,131 @@ __publicField(SimpleStepViewer, "dependencies", [
   StakeEventsViewerMoniker
 ]);
 __publicField(SimpleStepViewer, "monikers", [StepViewerMoniker2]);
+__publicField(SimpleStepViewer, "surface", "node");
 SimpleStepViewer = __decorateClass([
-  creatableProvider10()
+  creatableProvider14()
 ], SimpleStepViewer);
 
-// src/buildProviderLocator.ts
-function buildProviderLocator({ context = getEmptyProviderContext(ConfigZod.parse({})) } = {}) {
-  const {
-    config,
-    locator,
-    singletons = {},
-    caches = {},
-    ...restOfContext
-  } = context;
-  return new ProviderFactoryLocator({
-    ...restOfContext,
-    config,
-    singletons,
-    caches
-  }, locator?.registry);
-}
-function buildSimpleProviderLocator(params) {
-  const locator = buildProviderLocator(params);
-  const positions = [];
-  locator.registerMany([
-    SimpleStakeViewer2.factory(SimpleStakeViewer2.dependencies, { positions }),
-    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, { positions }),
-    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}),
-    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {})
-  ]);
-  return registerGatewayWithLocator(locator, params?.signerAccount);
-}
-async function buildJsonRpcProviderLocator(params) {
-  const locator = buildProviderLocator(params);
-  const transportFactory = params.transportFactory;
-  const positions = [];
-  locator.registerMany([
-    JsonRpcStakeTotalsViewer.factory(
-      JsonRpcStakeTotalsViewer.dependencies,
-      { transport: await transportFactory(StakeTotalsViewerRpcSchemas) }
-    ),
-    JsonRpcAccountBalanceViewer.factory(
-      JsonRpcAccountBalanceViewer.dependencies,
-      { transport: await transportFactory(AccountBalanceViewerRpcSchemas) }
-    ),
-    JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, { transport: await transportFactory(BlockViewerRpcSchemas) }),
-    JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas) }),
-    JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas) }),
-    JsonRpcNetworkStakeViewer.factory(
-      JsonRpcNetworkStakeViewer.dependencies,
-      { transport: await transportFactory(NetworkStakeViewerRpcSchemas) }
-    ),
-    JsonRpcTimeSyncViewer.factory(JsonRpcTimeSyncViewer.dependencies, { transport: await transportFactory(TimeSyncViewerRpcSchemas) }),
-    JsonRpcNetworkStakeStepRewardsViewer.factory(
-      JsonRpcNetworkStakeStepRewardsViewer.dependencies,
-      { transport: await transportFactory({}) }
-    ),
-    JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, { transport: await transportFactory(XyoRunnerRpcSchemas) }),
-    JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, { transport: await transportFactory(XyoViewerRpcSchemas) }),
-    SimpleStakeViewer2.factory(SimpleStakeViewer2.dependencies, { positions }),
-    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, { positions }),
-    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {})
-  ]);
-  return registerGatewayWithLocator(locator, params?.signerAccount);
+// src/locators/providerCandidates.ts
+var PROVIDER_IMPLEMENTATIONS = [
+  JsonRpcAccountBalanceViewer,
+  JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolViewer,
+  JsonRpcNetworkStakeViewer,
+  JsonRpcStakeTotalsViewer,
+  JsonRpcStakeViewer,
+  JsonRpcTimeSyncViewer,
+  JsonRpcTransactionViewer,
+  JsonRpcXyoRunner,
+  JsonRpcXyoSigner,
+  JsonRpcXyoViewer,
+  NodeXyoRunner,
+  NodeXyoViewer,
+  RestDataLakeRunner,
+  RestDataLakeViewer,
+  SimpleAccountBalanceViewer,
+  SimpleBlockRewardViewer,
+  SimpleBlockValidationViewer,
+  SimpleBlockViewer,
+  SimpleChainContractViewer,
+  SimpleDeadLetterQueueRunner,
+  SimpleDeadLetterQueueViewer,
+  SimpleFinalizationRunner,
+  SimpleFinalizationViewer,
+  SimpleMempoolRunner2,
+  SimpleMempoolViewer,
+  SimpleNetworkStakeViewer,
+  SimpleStakeEventsViewer,
+  SimpleStakeTotalsViewer,
+  SimpleStakeViewer,
+  SimpleStepRewardsByPositionViewer,
+  SimpleStepRewardsByStakerViewer,
+  SimpleStepRewardsByStepViewer,
+  SimpleStepRewardsTotalViewer,
+  SimpleStepRewardsViewer,
+  SimpleStepViewer,
+  SimpleTimeSyncViewer,
+  SimpleTransactionValidationViewer,
+  SimpleTransactionViewer,
+  SimpleWindowedBlockViewer,
+  SimpleXyoConnectionRunner,
+  SimpleXyoConnectionViewer,
+  SimpleXyoGateway,
+  SimpleXyoGatewayRunner,
+  SimpleXyoRunner,
+  SimpleXyoViewer
+];
+function allProviderCandidates() {
+  return providerCandidatesFromClasses(PROVIDER_IMPLEMENTATIONS);
 }
-function buildLocalProviderLocator(params) {
-  const locator = buildSimpleProviderLocator(params);
-  const {
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist,
-    balancesSummaryMap,
-    transfersSummaryMap,
-    finalizedArchivist,
-    node
-  } = params;
-  locator.registerMany([
-    SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
-    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, { finalizedArchivist }),
-    SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
-    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 1e4, syncInterval: 1e4 }),
-    NodeXyoViewer.factory(NodeXyoViewer.dependencies, { node })
-  ]);
-  return registerGatewayWithLocator(locator, params?.signerAccount);
+
+// src/locators/locatorFromAdaptedConfig.ts
+function locatorFromAdaptedConfig(options) {
+  const adapted = adaptLegacyConfig(options.config);
+  const needs = options.needs ?? needsFromProviderBindings(adapted);
+  const candidates = options.candidates ?? allProviderCandidates();
+  if (options.validateDepsOnRegister === true) {
+    const plan = resolveProvidersFromConfig(needs, candidates, adapted);
+    const locator = new ProviderFactoryLocator3({
+      singletons: {},
+      caches: {},
+      ...options.context,
+      config: adapted
+    }, {}, true);
+    registerFactoriesFromPlan(locator, plan);
+    return locator;
+  }
+  return locatorFromConfig({
+    candidates,
+    config: adapted,
+    context: options.context,
+    needs
+  });
 }
 
-// src/buildProviderLocatorV2.ts
-import {
-  ProviderFactoryLocator as ProviderFactoryLocator2,
-  SimpleAccountBalanceViewer as SimpleAccountBalanceViewer2,
-  SimpleBlockViewer as SimpleBlockViewer2,
-  SimpleFinalizationViewer as SimpleFinalizationViewer2,
-  SimpleMempoolRunner as SimpleMempoolRunner2,
-  SimpleMempoolViewer as SimpleMempoolViewer2,
-  SimpleTimeSyncViewer as SimpleTimeSyncViewer2,
-  SimpleWindowedBlockViewer as SimpleWindowedBlockViewer2,
-  SimpleXyoRunner as SimpleXyoRunner2
-} from "@xyo-network/xl1-protocol-sdk";
-import {
-  AccountBalanceViewerRpcSchemas as AccountBalanceViewerRpcSchemas2,
-  BlockViewerRpcSchemas as BlockViewerRpcSchemas2,
-  JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2,
-  JsonRpcBlockViewer as JsonRpcBlockViewer2,
-  JsonRpcMempoolRunner as JsonRpcMempoolRunner2,
-  JsonRpcMempoolViewer as JsonRpcMempoolViewer2,
-  JsonRpcNetworkStakeStepRewardsViewer as JsonRpcNetworkStakeStepRewardsViewer2,
-  JsonRpcNetworkStakeViewer as JsonRpcNetworkStakeViewer2,
-  JsonRpcStakeTotalsViewer as JsonRpcStakeTotalsViewer2,
-  JsonRpcTimeSyncViewer as JsonRpcTimeSyncViewer2,
-  JsonRpcXyoRunner as JsonRpcXyoRunner2,
-  JsonRpcXyoViewer as JsonRpcXyoViewer2,
-  MempoolRunnerRpcSchemas as MempoolRunnerRpcSchemas2,
-  MempoolViewerRpcSchemas as MempoolViewerRpcSchemas2,
-  NetworkStakeViewerRpcSchemas as NetworkStakeViewerRpcSchemas2,
-  StakeTotalsViewerRpcSchemas as StakeTotalsViewerRpcSchemas2,
-  TimeSyncViewerRpcSchemas as TimeSyncViewerRpcSchemas2,
-  XyoRunnerRpcSchemas as XyoRunnerRpcSchemas2,
-  XyoViewerRpcSchemas as XyoViewerRpcSchemas2
-} from "@xyo-network/xl1-rpc";
-function buildEmptyProviderLocator(config) {
-  return new ProviderFactoryLocator2({
+// src/locators/remoteLocatorFromConfig.ts
+function remoteLocatorFromConfig(context, validateDepsOnRegister = false, validators) {
+  const config = adaptLegacyConfig2(context.config);
+  const locator = locatorFromAdaptedConfig({
     config,
-    singletons: {},
-    caches: {}
+    context: {
+      caches: context.caches,
+      singletons: context.singletons
+    },
+    needs: needsFromConnectionTypes(config, ["rpc"]),
+    validateDepsOnRegister
   });
-}
-function buildSimpleProviderLocatorV2(config, account) {
-  const locator = buildEmptyProviderLocator(config);
-  locator.registerMany([
-    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {}),
-    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {})
-  ]);
-  return registerGatewayWithLocator(locator, account);
-}
-async function buildJsonRpcProviderLocatorV2(config, transportFactory, account) {
-  const locator = buildEmptyProviderLocator(config);
-  locator.registerMany([
-    JsonRpcStakeTotalsViewer2.factory(
-      JsonRpcStakeTotalsViewer2.dependencies,
-      { transport: await transportFactory(StakeTotalsViewerRpcSchemas2) }
-    ),
-    JsonRpcAccountBalanceViewer2.factory(
-      JsonRpcAccountBalanceViewer2.dependencies,
-      { transport: await transportFactory(AccountBalanceViewerRpcSchemas2) }
-    ),
-    JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, { transport: await transportFactory(BlockViewerRpcSchemas2) }),
-    JsonRpcMempoolRunner2.factory(JsonRpcMempoolRunner2.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas2) }),
-    JsonRpcMempoolViewer2.factory(JsonRpcMempoolViewer2.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas2) }),
-    JsonRpcNetworkStakeViewer2.factory(
-      JsonRpcNetworkStakeViewer2.dependencies,
-      { transport: await transportFactory(NetworkStakeViewerRpcSchemas2) }
-    ),
-    JsonRpcTimeSyncViewer2.factory(JsonRpcTimeSyncViewer2.dependencies, { transport: await transportFactory(TimeSyncViewerRpcSchemas2) }),
-    JsonRpcNetworkStakeStepRewardsViewer2.factory(
-      JsonRpcNetworkStakeStepRewardsViewer2.dependencies,
-      { transport: await transportFactory({}) }
-    ),
-    JsonRpcXyoRunner2.factory(JsonRpcXyoRunner2.dependencies, { transport: await transportFactory(XyoRunnerRpcSchemas2) }),
-    JsonRpcXyoViewer2.factory(JsonRpcXyoViewer2.dependencies, { transport: await transportFactory(XyoViewerRpcSchemas2) })
-  ]);
-  return registerGatewayWithLocator(locator, account);
-}
-function buildLocalProviderLocatorV2(config, params) {
-  const {
-    account,
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist,
-    balancesSummaryMap,
-    transfersSummaryMap,
-    finalizedArchivist
-  } = params;
-  const locator = buildSimpleProviderLocatorV2(config, account);
-  locator.registerMany([
-    SimpleMempoolViewer2.factory(SimpleMempoolViewer2.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleMempoolRunner2.factory(SimpleMempoolRunner2.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleAccountBalanceViewer2.factory(SimpleAccountBalanceViewer2.dependencies, { balancesSummaryMap, transfersSummaryMap }),
-    SimpleFinalizationViewer2.factory(SimpleFinalizationViewer2.dependencies, { finalizedArchivist }),
-    SimpleBlockViewer2.factory(SimpleBlockViewer2.dependencies, { finalizedArchivist }),
-    SimpleXyoRunner2.factory(SimpleXyoRunner2.dependencies, {}),
-    SimpleWindowedBlockViewer2.factory(SimpleWindowedBlockViewer2.dependencies, { maxWindowSize: 1e4, syncInterval: 1e4 }),
-    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {})
-  ]);
-  return locator;
-}
-
-// src/buildSimpleXyoSignerV2.ts
-import { XyoSignerMoniker } from "@xyo-network/xl1-protocol-lib";
-import { ProviderFactoryLocator as ProviderFactoryLocator3, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-protocol-sdk";
-async function buildSimpleXyoSignerV2(context, account) {
-  const locator = new ProviderFactoryLocator3(context);
   locator.register(
-    SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, { account })
+    SimpleStakeEventsViewer2.factory(
+      SimpleStakeEventsViewer2.dependencies,
+      { positions: [] }
+    )
   );
-  return await locator.getInstance(XyoSignerMoniker);
-}
-
-// src/creators/createRestDataLake.ts
-import { RestDataLakeRunner as RestDataLakeRunner2, RestDataLakeViewer as RestDataLakeViewer3 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/locators/baseConfigFactoryLocator.ts
-import {
-  BaseConfigZod,
-  ProviderFactoryLocator as ProviderFactoryLocator4
-} from "@xyo-network/xl1-protocol-sdk";
-async function baseConfigFactoryLocator() {
-  const config = BaseConfigZod.parse({});
-  return new ProviderFactoryLocator4({
-    config,
-    singletons: {},
-    caches: {}
-  }, {});
-}
-
-// src/locators/basicRemoteRunnerLocator.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import {
-  ProviderFactoryLocator as ProviderFactoryLocator6,
-  RestDataLakeRunner,
-  RestDataLakeViewer as RestDataLakeViewer2,
-  SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2
-} from "@xyo-network/xl1-protocol-sdk";
-import { JsonRpcXyoRunner as JsonRpcXyoRunner3, JsonRpcXyoSigner } from "@xyo-network/xl1-rpc";
-
-// src/locators/basicRemoteViewerLocator.ts
-import { isDefined } from "@xylabs/sdk-js";
-import {
-  ActorConfigZod,
-  RestDataLakeViewer,
-  SimpleXyoGateway as SimpleXyoGateway2
-} from "@xyo-network/xl1-protocol-sdk";
-
-// src/SimpleXyoConnectionViewer.ts
-import {
-  DataLakeViewerMoniker as DataLakeViewerMoniker2,
-  XyoConnectionMoniker as XyoConnectionMoniker2,
-  XyoViewerMoniker as XyoViewerMoniker3
-} from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider10, creatableProvider as creatableProvider11 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleXyoConnectionViewer = class extends AbstractCreatableProvider10 {
-  moniker = SimpleXyoConnectionViewer.defaultMoniker;
-  _network;
-  _storage;
-  _viewer;
-  get network() {
-    return this._network;
-  }
-  get storage() {
-    return this._storage;
-  }
-  get viewer() {
-    return this._viewer;
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._viewer = await this.locator.getInstance(XyoViewerMoniker3);
-    const dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker2);
-    this._storage = dataLakeViewer;
-  }
-};
-__publicField(SimpleXyoConnectionViewer, "defaultMoniker", XyoConnectionMoniker2);
-__publicField(SimpleXyoConnectionViewer, "dependencies", [XyoViewerMoniker3]);
-__publicField(SimpleXyoConnectionViewer, "monikers", [XyoConnectionMoniker2]);
-SimpleXyoConnectionViewer = __decorateClass([
-  creatableProvider11()
-], SimpleXyoConnectionViewer);
-
-// src/locators/remoteLocatorFromConfig.ts
-import {
-  ProviderFactoryLocator as ProviderFactoryLocator5,
-  SimpleBlockValidationViewer,
-  SimpleStakeEventsViewer as SimpleStakeEventsViewer3
-} from "@xyo-network/xl1-protocol-sdk";
-import {
-  JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3,
-  JsonRpcBlockViewer as JsonRpcBlockViewer3,
-  JsonRpcFinalizationViewer,
-  JsonRpcMempoolRunner as JsonRpcMempoolRunner3,
-  JsonRpcMempoolViewer as JsonRpcMempoolViewer3,
-  JsonRpcNetworkStakeViewer as JsonRpcNetworkStakeViewer3,
-  JsonRpcStakeViewer,
-  JsonRpcTransactionViewer,
-  JsonRpcXyoViewer as JsonRpcXyoViewer3
-} from "@xyo-network/xl1-rpc";
-
-// src/locators/commonProvidersFromConfig.ts
-import {
-  SimpleBlockRewardViewer,
-  SimpleTimeSyncViewer as SimpleTimeSyncViewer3,
-  SimpleTransactionValidationViewer,
-  SimpleTransactionViewer,
-  SimpleWindowedBlockViewer as SimpleWindowedBlockViewer3
-} from "@xyo-network/xl1-protocol-sdk";
-function commonProvidersFromConfig() {
-  return [
-    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer3.factory(SimpleTimeSyncViewer3.dependencies, {}),
-    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {}),
-    SimpleWindowedBlockViewer3.factory(SimpleWindowedBlockViewer3.dependencies, { maxWindowSize: 1e3, syncInterval: 1e4 }),
-    SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
-    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {}),
-    SimpleTransactionValidationViewer.factory(SimpleTransactionValidationViewer.dependencies, {})
-  ];
-}
-
-// src/locators/remoteLocatorFromConfig.ts
-function remoteLocatorFromConfig(context, validateDepsOnRegister = false, validators) {
-  const locator = new ProviderFactoryLocator5(context, {}, validateDepsOnRegister);
-  locator.registerMany([
-    ...commonProvidersFromConfig(),
-    JsonRpcMempoolViewer3.factory(JsonRpcMempoolViewer3.dependencies, {}),
-    JsonRpcMempoolRunner3.factory(JsonRpcMempoolRunner3.dependencies, {}),
-    JsonRpcAccountBalanceViewer3.factory(JsonRpcAccountBalanceViewer3.dependencies, {}),
-    JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {}),
-    JsonRpcBlockViewer3.factory(JsonRpcBlockViewer3.dependencies, {}),
-    JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
-    JsonRpcNetworkStakeViewer3.factory(JsonRpcNetworkStakeViewer3.dependencies, {}),
-    JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {}),
-    SimpleStakeEventsViewer3.factory(SimpleStakeEventsViewer3.dependencies, { positions: [] }),
-    JsonRpcXyoViewer3.factory(JsonRpcXyoViewer3.dependencies, {}),
-    SimpleBlockValidationViewer.factory(
-      SimpleBlockValidationViewer.dependencies,
-      { state: validators?.validateHydratedBlockState, protocol: validators?.validateHydratedBlock }
+  locator.register(
+    SimpleWindowedBlockViewer2.factory(
+      SimpleWindowedBlockViewer2.dependencies,
+      { maxWindowSize: 1e3, syncInterval: 1e4 }
     )
-  ]);
+  );
+  locator.register(
+    SimpleTransactionValidationViewer2.factory(
+      SimpleTransactionValidationViewer2.dependencies,
+      {}
+    )
+  );
+  if (validators?.validateHydratedBlock !== void 0 || validators?.validateHydratedBlockState !== void 0) {
+    locator.register(
+      SimpleBlockValidationViewer2.factory(
+        SimpleBlockValidationViewer2.dependencies,
+        {
+          protocol: validators.validateHydratedBlock,
+          state: validators.validateHydratedBlockState
+        }
+      )
+    );
+  }
   return locator;
 }
 
@@ -1485,9 +1599,9 @@ async function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, op
     SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
     ...options?.additionalProviders ?? []
   ]);
-  if (isDefined(dataLakeEndpoint)) {
+  if (isDefined2(dataLakeEndpoint)) {
     const dataLakeViewerParams = { endpoint: dataLakeEndpoint };
-    locator.register(RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, dataLakeViewerParams));
+    locator.register(RestDataLakeViewer2.factory(RestDataLakeViewer2.dependencies, dataLakeViewerParams));
   }
   locator.freeze();
   return locator;
@@ -1496,10 +1610,10 @@ async function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, op
 // src/locators/basicRemoteRunnerLocator.ts
 async function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, dataLakeEndpoint, options) {
   const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, options);
-  const locator = new ProviderFactoryLocator6(remoteViewerLocator.context, {});
+  const locator = new ProviderFactoryLocator4(remoteViewerLocator.context, {});
   const providers = [
     SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
-    JsonRpcXyoRunner3.factory(JsonRpcXyoRunner3.dependencies, {})
+    JsonRpcXyoRunner2.factory(JsonRpcXyoRunner2.dependencies, {})
   ];
   if (options?.skipGatewayRunner !== true) {
     providers.push(
@@ -1512,36 +1626,39 @@ async function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, dat
   ]);
   if (options?.signerFactory) {
     locator.register(options.signerFactory);
-  } else if (isDefined2(signerTransport)) {
+  } else if (isDefined3(signerTransport)) {
     locator.register(
-      JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, { transport: signerTransport })
+      JsonRpcXyoSigner2.factory(JsonRpcXyoSigner2.dependencies, { transport: signerTransport })
     );
   } else {
     throw new Error("basicRemoteRunnerLocator requires either signerTransport or options.signerFactory");
   }
-  if (isDefined2(dataLakeEndpoint)) {
+  if (isDefined3(dataLakeEndpoint)) {
     const dataLakeParams = { endpoint: dataLakeEndpoint };
-    locator.register(RestDataLakeViewer2.factory(RestDataLakeViewer2.dependencies, dataLakeParams));
-    locator.register(RestDataLakeRunner.factory(RestDataLakeRunner.dependencies, dataLakeParams));
+    locator.register(RestDataLakeViewer3.factory(RestDataLakeViewer3.dependencies, dataLakeParams));
+    locator.register(RestDataLakeRunner2.factory(RestDataLakeRunner2.dependencies, dataLakeParams));
   }
   locator.freeze();
   return locator;
 }
 
 // src/locators/commonLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator7 } from "@xyo-network/xl1-protocol-sdk";
+import { ProviderFactoryLocator as ProviderFactoryLocator5 } from "@xyo-network/xl1-protocol-sdk";
 function commonLocatorFromConfig(context, validateDepsOnRegister = false) {
-  const locator = new ProviderFactoryLocator7(context, {}, validateDepsOnRegister);
-  locator.registerMany(commonProvidersFromConfig());
-  return locator;
+  return new ProviderFactoryLocator5(context, {}, validateDepsOnRegister);
+}
+
+// src/locators/commonProvidersFromConfig.ts
+function commonProvidersFromConfig() {
+  return [];
 }
 
 // src/locators/rootLocatorFromConfig.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 async function rootLocatorFromConfig(context, validateDepsOnRegister = false, validators) {
   const { config } = context;
   const newLocator = config.remote.rpc ? await remoteLocatorFromConfig(context, validateDepsOnRegister, validators) : void 0;
-  const locator = assertEx5(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
+  const locator = assertEx7(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
   locator.freeze();
   return locator;
 }
@@ -1550,260 +1667,56 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false, va
 async function createRestDataLakeViewer(dataLakeEndpoint) {
   const locator = await baseConfigFactoryLocator();
   const dataLakeViewerParams = { endpoint: dataLakeEndpoint };
-  locator.register(RestDataLakeViewer3.factory(RestDataLakeViewer3.dependencies, dataLakeViewerParams));
+  locator.register(RestDataLakeViewer4.factory(RestDataLakeViewer4.dependencies, dataLakeViewerParams));
   locator.freeze();
-  return await locator.getInstance(RestDataLakeViewer3.defaultMoniker);
+  return await locator.getInstance(RestDataLakeViewer4.defaultMoniker);
 }
 async function createRestDataLakeRunner(dataLakeEndpoint) {
   const locator = await baseConfigFactoryLocator();
   const dataLakeRunnerParams = { endpoint: dataLakeEndpoint };
-  locator.register(RestDataLakeRunner2.factory(RestDataLakeRunner2.dependencies, dataLakeRunnerParams));
+  locator.register(RestDataLakeRunner3.factory(RestDataLakeRunner3.dependencies, dataLakeRunnerParams));
   locator.freeze();
-  return await locator.getInstance(RestDataLakeRunner2.defaultMoniker);
+  return await locator.getInstance(RestDataLakeRunner3.defaultMoniker);
 }
 
-// src/NodeXyoRunner.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { asArchivistInstance } from "@xyo-network/sdk-js";
-import { XyoRunnerMoniker as XyoRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+// src/registerHelpers.ts
 import {
-  AbstractCreatableProvider as AbstractCreatableProvider11,
-  creatableProvider as creatableProvider12,
-  SimpleMempoolRunner as SimpleMempoolRunner3
+  SimpleStakeEventsViewer as SimpleStakeEventsViewer3,
+  SimpleStakeViewer as SimpleStakeViewer2,
+  SimpleXyoGateway as SimpleXyoGateway3,
+  SimpleXyoGatewayRunner as SimpleXyoGatewayRunner3,
+  SimpleXyoSigner as SimpleXyoSigner2
 } from "@xyo-network/xl1-protocol-sdk";
-var NodeXyoRunner = class extends AbstractCreatableProvider11 {
-  moniker = NodeXyoRunner.defaultMoniker;
-  _mempoolRunner;
-  _pendingBlocksArchivist;
-  _pendingTransactionsArchivist;
-  get mempool() {
-    return this._mempoolRunner;
-  }
-  get node() {
-    return this.params.node;
-  }
-  get pendingBlocksArchivist() {
-    return this._pendingBlocksArchivist;
-  }
-  get pendingBlocksArchivistPath() {
-    return this.params.pendingBlocksArchivistPath ?? "XYOChain:Pending:Blocks";
-  }
-  get pendingTransactionsArchivist() {
-    return this._pendingTransactionsArchivist;
-  }
-  get pendingTransactionsArchivistPath() {
-    return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
-  }
-  async broadcastTransaction(transaction) {
-    const [txHash] = await this.mempool.submitTransactions([transaction]);
-    return txHash;
-  }
-  getArchivist = async (identifier) => {
-    const archivist = await this.node.resolve(identifier);
-    return assertEx6(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
-  };
-  async startHandler() {
-    await super.startHandler();
-    this._pendingTransactionsArchivist = assertEx6(
-      await this.getArchivist(this.pendingTransactionsArchivistPath),
-      () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`
-    );
-    this._pendingBlocksArchivist = assertEx6(
-      await this.getArchivist(this.pendingBlocksArchivistPath),
-      () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`
-    );
-    this._mempoolRunner = assertEx6(await SimpleMempoolRunner3.create({
-      context: this.context,
-      pendingTransactionsArchivist: this.pendingTransactionsArchivist,
-      pendingBlocksArchivist: this.pendingBlocksArchivist
-    }), () => "Failed to create SimpleMempoolRunner");
+var registerGatewayRunnerWithLocatorIfProvided = (locator, params) => {
+  const account = params?.signerAccount;
+  if (account) {
+    locator.registerMany([
+      SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, { account }),
+      SimpleXyoGatewayRunner3.factory(SimpleXyoGatewayRunner3.dependencies, {})
+    ]);
   }
+  return locator;
 };
-__publicField(NodeXyoRunner, "defaultMoniker", XyoRunnerMoniker2);
-__publicField(NodeXyoRunner, "dependencies", []);
-__publicField(NodeXyoRunner, "monikers", [XyoRunnerMoniker2]);
-NodeXyoRunner = __decorateClass([
-  creatableProvider12()
-], NodeXyoRunner);
-
-// src/SimpleDeadLetterQueueRunner.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-import { isHashMeta, PayloadBuilder } from "@xyo-network/sdk-js";
-import {
-  DeadLetterQueueRunnerMoniker,
-  isBlockRejection,
-  isTransactionRejection
-} from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider12, creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleDeadLetterQueueRunner = class extends AbstractCreatableProvider12 {
-  moniker = SimpleDeadLetterQueueRunner.defaultMoniker;
-  get rejectedBlocksArchivist() {
-    return this.params.rejectedBlocksArchivist;
-  }
-  get rejectedTransactionsArchivist() {
-    return this.params.rejectedTransactionsArchivist;
-  }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      rejectedBlocksArchivist: assertEx7(params?.rejectedBlocksArchivist, () => "rejectedBlocksArchivist is required"),
-      rejectedTransactionsArchivist: assertEx7(params?.rejectedTransactionsArchivist, () => "rejectedTransactionsArchivist is required")
-    };
-  }
-  async pruneRejectedBlocks({
-    batchSize = 10,
-    maxPrune = 1e3,
-    maxCheck = 1e3
-  } = {}) {
-    let total = 0;
-    let pruned = 0;
-    let cursor;
-    let batch = await this.rejectedBlocksArchivist.next({
-      limit: batchSize,
-      cursor,
-      order: "desc"
-    });
-    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
-      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isBlockRejection(p)).map((p) => p._hash);
-      pruned += pruneHashes.length;
-      total += batch.length;
-      if (pruneHashes.length > 0) {
-        await this.rejectedBlocksArchivist.delete(pruneHashes);
-      }
-      const pruneSet = new Set(pruneHashes);
-      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
-      cursor = lastSurvivor?._sequence ?? cursor;
-      batch = await this.rejectedBlocksArchivist.next({
-        limit: batchSize,
-        cursor,
-        order: "desc"
-      });
-    }
-    return [pruned, total];
-  }
-  async pruneRejectedTransactions({
-    batchSize = 10,
-    maxPrune = 1e3,
-    maxCheck = 1e3
-  } = {}) {
-    let total = 0;
-    let pruned = 0;
-    let cursor;
-    let batch = await this.rejectedTransactionsArchivist.next({
-      limit: batchSize,
-      cursor,
-      order: "desc"
-    });
-    while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
-      const pruneHashes = batch.filter(isHashMeta).filter((p) => !isTransactionRejection(p)).map((p) => p._hash);
-      pruned += pruneHashes.length;
-      total += batch.length;
-      if (pruneHashes.length > 0) {
-        await this.rejectedTransactionsArchivist.delete(pruneHashes);
-      }
-      const pruneSet = new Set(pruneHashes);
-      const lastSurvivor = batch.findLast((p) => isHashMeta(p) && !pruneSet.has(p._hash));
-      cursor = lastSurvivor?._sequence ?? cursor;
-      batch = await this.rejectedTransactionsArchivist.next({
-        limit: batchSize,
-        cursor,
-        order: "desc"
-      });
-    }
-    return [pruned, total];
-  }
-  async rejectBlock(rejection) {
-    const withMeta = await PayloadBuilder.addHashMeta(rejection);
-    const inserted = await this.rejectedBlocksArchivist.insert([withMeta]);
-    return inserted.length > 0;
-  }
-  async rejectTransaction(rejection) {
-    const withMeta = await PayloadBuilder.addHashMeta(rejection);
-    const inserted = await this.rejectedTransactionsArchivist.insert([withMeta]);
-    return inserted.length > 0;
+var registerGatewayWithLocator = (locator, account) => {
+  locator.registerMany([
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
+    SimpleXyoGateway3.factory(SimpleXyoGateway3.dependencies, {})
+  ]);
+  if (account) {
+    locator.registerMany([
+      SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, { account }),
+      SimpleXyoGatewayRunner3.factory(SimpleXyoGatewayRunner3.dependencies, {})
+    ]);
   }
+  return locator;
 };
-__publicField(SimpleDeadLetterQueueRunner, "defaultMoniker", DeadLetterQueueRunnerMoniker);
-__publicField(SimpleDeadLetterQueueRunner, "dependencies", []);
-__publicField(SimpleDeadLetterQueueRunner, "monikers", [DeadLetterQueueRunnerMoniker]);
-SimpleDeadLetterQueueRunner = __decorateClass([
-  creatableProvider13()
-], SimpleDeadLetterQueueRunner);
-
-// src/SimpleDeadLetterQueueViewer.ts
-import {
-  exists,
-  isDefined as isDefined3,
-  isHash
-} from "@xylabs/sdk-js";
-import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk-js";
-import {
-  DeadLetterQueueViewerMoniker,
-  isBlockRejection as isBlockRejection2,
-  isTransactionRejection as isTransactionRejection2
-} from "@xyo-network/xl1-protocol-lib";
-import { AbstractCreatableProvider as AbstractCreatableProvider13, creatableProvider as creatableProvider14 } from "@xyo-network/xl1-protocol-sdk";
-var SimpleDeadLetterQueueViewer = class extends AbstractCreatableProvider13 {
-  moniker = SimpleDeadLetterQueueViewer.defaultMoniker;
-  get rejectedBlocksArchivist() {
-    return this.params.rejectedBlocksArchivist;
-  }
-  get rejectedTransactionsArchivist() {
-    return this.params.rejectedTransactionsArchivist;
-  }
-  async rejectedBlocks({
-    cursor: providedCursor,
-    limit = 100,
-    rejector
-  } = {}) {
-    let cursor;
-    if (isHash(providedCursor)) {
-      const [p] = await this.rejectedBlocksArchivist.get([providedCursor]);
-      if (isDefined3(p)) {
-        cursor = p._sequence;
-      }
-    }
-    const payloads = await this.rejectedBlocksArchivist.next({
-      order: "desc",
-      limit,
-      cursor
-    });
-    const rejections = payloads.filter(isHashMeta2).map((p) => isBlockRejection2(p) ? p : void 0).filter(exists);
-    if (rejector !== void 0) {
-      return rejections.filter((r) => r.rejector === rejector);
-    }
-    return rejections;
-  }
-  async rejectedTransactions({
-    cursor: providedCursor,
-    limit = 100,
-    rejector
-  } = {}) {
-    let cursor;
-    if (isHash(providedCursor)) {
-      const [p] = await this.rejectedTransactionsArchivist.get([providedCursor]);
-      if (isDefined3(p)) {
-        cursor = p._sequence;
-      }
-    }
-    const payloads = await this.rejectedTransactionsArchivist.next({
-      order: "desc",
-      limit,
-      cursor
-    });
-    const rejections = payloads.filter(isHashMeta2).map((p) => isTransactionRejection2(p) ? p : void 0).filter(exists);
-    if (rejector !== void 0) {
-      return rejections.filter((r) => r.rejector === rejector);
-    }
-    return rejections;
-  }
+var registerSimpleStakeViewerWithLocator = (locator, positions) => {
+  locator.registerMany([
+    SimpleStakeViewer2.factory(SimpleStakeViewer2.dependencies, { positions }),
+    SimpleStakeEventsViewer3.factory(SimpleStakeEventsViewer3.dependencies, { positions })
+  ]);
+  return locator;
 };
-__publicField(SimpleDeadLetterQueueViewer, "defaultMoniker", DeadLetterQueueViewerMoniker);
-__publicField(SimpleDeadLetterQueueViewer, "dependencies", []);
-__publicField(SimpleDeadLetterQueueViewer, "monikers", [DeadLetterQueueViewerMoniker]);
-SimpleDeadLetterQueueViewer = __decorateClass([
-  creatableProvider14()
-], SimpleDeadLetterQueueViewer);
 export {
   NodeXyoRunner,
   NodeXyoViewer,
@@ -1819,22 +1732,16 @@ export {
   SimpleXyoConnectionRunner,
   SimpleXyoConnectionViewer,
   SimpleXyoViewer,
+  allProviderCandidates,
   baseConfigFactoryLocator,
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
-  buildEmptyProviderLocator,
-  buildJsonRpcProviderLocator,
-  buildJsonRpcProviderLocatorV2,
-  buildLocalProviderLocator,
-  buildLocalProviderLocatorV2,
-  buildProviderLocator,
-  buildSimpleProviderLocator,
-  buildSimpleProviderLocatorV2,
   buildSimpleXyoSignerV2,
   commonLocatorFromConfig,
   commonProvidersFromConfig,
   createRestDataLakeRunner,
   createRestDataLakeViewer,
+  locatorFromAdaptedConfig,
   registerGatewayRunnerWithLocatorIfProvided,
   registerGatewayWithLocator,
   registerSimpleStakeViewerWithLocator,