@xyo-network/xl1-rpc 3.0.0 → 3.0.2

package/dist/neutral/index.mjs

@@ -222,13 +222,11 @@ var rpcMethodHandlersFromSigner = (signer) => {
   };
 };
 
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-import { MempoolRunnerMoniker as MempoolRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider } from "@xyo-network/xl1-protocol-sdk";
+// src/provider/datalake/JsonRpcDataLakeViewer.ts
+import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
 
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
-import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { elevatedTransaction, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
+// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 
 // src/types/DataLakePageRpc.ts
 var DataLakesPageMethodPrefix = "xyoDataLakes";
@@ -1566,7 +1564,14 @@ var DataLakePageRpcSchemas = {
   }
 };
 
-// src/provider/runner/JsonRpcRunner.ts
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+import { creatableProvider } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-lib";
+
+// src/provider/viewer/JsonRpcViewer.ts
 import {
   AbstractCreatableProvider,
   HttpRpcRemoteConfigZod,
@@ -1835,115 +1840,8 @@ var PostMessageRpcTransport = class {
   }
 };
 
-// src/provider/runner/JsonRpcRunner.ts
-var AbstractJsonRpcRunner = class extends AbstractCreatableProvider {
-  get transport() {
-    return this.params.transport;
-  }
-  async createHandler() {
-    this.params.transport ??= this.createTransport();
-    await super.createHandler();
-  }
-  createTransport() {
-    const httpRemoteConfig = HttpRpcRemoteConfigZod.safeParse(this.config.remote.rpc);
-    if (httpRemoteConfig.success) {
-      const { url } = httpRemoteConfig.data;
-      return new HttpRpcTransport(url, this.schemas());
-    }
-    const postMessageRemoteConfig = PostMessageRpcRemoteConfigZod.safeParse(this.config.remote.rpc);
-    if (postMessageRemoteConfig.success) {
-      const { networkId, sessionId } = postMessageRemoteConfig.data;
-      return new PostMessageRpcTransport(networkId, this.schemas(), sessionId, this.logger);
-    }
-    throw new Error("Unable to create transport");
-  }
-};
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
-var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
-  moniker = MempoolRunnerMoniker;
-  async submitBlocks(blocks) {
-    const result = await this.transport.sendRequest(
-      "mempoolRunner_submitBlocks",
-      [blocks]
-    );
-    return result;
-  }
-  async submitTransactions(transactions) {
-    const elevated = await Promise.all(
-      transactions.map(async ([bw, payloads]) => elevatedTransaction([
-        await PayloadBuilder.addHashMeta(bw),
-        await PayloadBuilder.addHashMeta(payloads)
-      ]))
-    );
-    const result = await this.transport.sendRequest(
-      "mempoolRunner_submitTransactions",
-      [elevated]
-    );
-    return result;
-  }
-  schemas() {
-    return MempoolRunnerRpcSchemas;
-  }
-};
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
-  prunePendingBlocks(_options) {
-    throw new Error("Method not implemented.");
-  }
-  prunePendingTransactions(_options) {
-    throw new Error("Method not implemented.");
-  }
-};
-__publicField(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker2);
-__publicField(JsonRpcMempoolRunner, "dependencies", []);
-__publicField(JsonRpcMempoolRunner, "monikers", [MempoolRunnerMoniker2]);
-JsonRpcMempoolRunner = __decorateClass([
-  creatableProvider()
-], JsonRpcMempoolRunner);
-
-// src/provider/runner/JsonRpcXyoRunner.ts
-import { MempoolRunnerMoniker as MempoolRunnerMoniker3, XyoRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider2 } from "@xyo-network/xl1-protocol-sdk";
-var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
-  moniker = JsonRpcXyoRunner.defaultMoniker;
-  _mempoolRunner;
-  get mempool() {
-    return this._mempoolRunner;
-  }
-  async broadcastTransaction(transaction) {
-    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker3);
-  }
-  schemas() {
-    return XyoRunnerRpcSchemas;
-  }
-};
-__publicField(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
-__publicField(JsonRpcXyoRunner, "dependencies", [MempoolRunnerMoniker3]);
-__publicField(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
-JsonRpcXyoRunner = __decorateClass([
-  creatableProvider2()
-], JsonRpcXyoRunner);
-
-// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider3 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
-import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-
 // src/provider/viewer/JsonRpcViewer.ts
-import {
-  AbstractCreatableProvider as AbstractCreatableProvider2,
-  HttpRpcRemoteConfigZod as HttpRpcRemoteConfigZod2,
-  PostMessageRpcRemoteConfigZod as PostMessageRpcRemoteConfigZod2
-} from "@xyo-network/xl1-protocol-sdk";
-var AbstractJsonRpcViewer = class extends AbstractCreatableProvider2 {
+var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
   _transport;
   get transport() {
     return this.params.transport;
@@ -1953,12 +1851,12 @@ var AbstractJsonRpcViewer = class extends AbstractCreatableProvider2 {
     await super.createHandler();
   }
   createTransport() {
-    const httpRemoteConfig = HttpRpcRemoteConfigZod2.safeParse(this.config.remote.rpc);
+    const httpRemoteConfig = HttpRpcRemoteConfigZod.safeParse(this.config.remote.rpc);
     if (httpRemoteConfig.success) {
       const { url } = httpRemoteConfig.data;
       return new HttpRpcTransport(url, this.schemas());
     }
-    const postMessageRemoteConfig = PostMessageRpcRemoteConfigZod2.safeParse(this.config.remote.rpc);
+    const postMessageRemoteConfig = PostMessageRpcRemoteConfigZod.safeParse(this.config.remote.rpc);
     if (postMessageRemoteConfig.success) {
       const { networkId, sessionId } = postMessageRemoteConfig.data;
       return new PostMessageRpcTransport(networkId, this.schemas(), sessionId, this.logger);
@@ -2006,11 +1904,13 @@ var JsonRpcAccountBalanceViewer = class extends JsonRpcAccountBalanceViewerMetho
     return result;
   }
 };
+__publicField(JsonRpcAccountBalanceViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcAccountBalanceViewer, "defaultMoniker", AccountBalanceViewerMoniker2);
 __publicField(JsonRpcAccountBalanceViewer, "dependencies", []);
 __publicField(JsonRpcAccountBalanceViewer, "monikers", [AccountBalanceViewerMoniker2]);
+__publicField(JsonRpcAccountBalanceViewer, "surface", "node");
 JsonRpcAccountBalanceViewer = __decorateClass([
-  creatableProvider3()
+  creatableProvider()
 ], JsonRpcAccountBalanceViewer);
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
@@ -2020,7 +1920,7 @@ import {
   calculateBlockRate,
   calculateStepSizeRate,
   calculateTimeRate,
-  creatableProvider as creatableProvider4
+  creatableProvider as creatableProvider2
 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
@@ -2167,16 +2067,18 @@ var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
     this._headPollTimer = null;
   }
 };
+__publicField(JsonRpcBlockViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcBlockViewer, "defaultMoniker", BlockViewerMoniker2);
 __publicField(JsonRpcBlockViewer, "dependencies", []);
 __publicField(JsonRpcBlockViewer, "monikers", [BlockViewerMoniker2]);
+__publicField(JsonRpcBlockViewer, "surface", "node");
 JsonRpcBlockViewer = __decorateClass([
-  creatableProvider4()
+  creatableProvider2()
 ], JsonRpcBlockViewer);
 
 // src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
 import { FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider5 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider3 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewerMethods.ts
 import { FinalizationViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2213,16 +2115,18 @@ var JsonRpcFinalizationViewer = class extends JsonRpcFinalizationViewerMethods {
     return head[0].block;
   }
 };
+__publicField(JsonRpcFinalizationViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker2);
 __publicField(JsonRpcFinalizationViewer, "dependencies", []);
 __publicField(JsonRpcFinalizationViewer, "monikers", [FinalizationViewerMoniker2]);
+__publicField(JsonRpcFinalizationViewer, "surface", "node");
 JsonRpcFinalizationViewer = __decorateClass([
-  creatableProvider5()
+  creatableProvider3()
 ], JsonRpcFinalizationViewer);
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
 import { MempoolViewerMoniker as MempoolViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider6 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider4 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts
 import { MempoolViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2250,18 +2154,20 @@ var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
 var JsonRpcMempoolViewer = class extends JsonRpcMempoolViewerMethods {
 };
+__publicField(JsonRpcMempoolViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcMempoolViewer, "defaultMoniker", MempoolViewerMoniker2);
 __publicField(JsonRpcMempoolViewer, "dependencies", []);
 __publicField(JsonRpcMempoolViewer, "monikers", [MempoolViewerMoniker2]);
+__publicField(JsonRpcMempoolViewer, "surface", "node");
 JsonRpcMempoolViewer = __decorateClass([
-  creatableProvider6()
+  creatableProvider4()
 ], JsonRpcMempoolViewer);
 
 // src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
 import {
   NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider7 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider5 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts
 import { NetworkStakeStepRewardsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2287,11 +2193,13 @@ var JsonRpcNetworkStakeStepRewardsViewer = class extends JsonRpcNetworkStakeStep
     return this.params.total;
   }
 };
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcNetworkStakeStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
 __publicField(JsonRpcNetworkStakeStepRewardsViewer, "dependencies", []);
 __publicField(JsonRpcNetworkStakeStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "surface", "node");
 JsonRpcNetworkStakeStepRewardsViewer = __decorateClass([
-  creatableProvider7()
+  creatableProvider5()
 ], JsonRpcNetworkStakeStepRewardsViewer);
 var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStakeStepRewardsViewer {
 };
@@ -2301,7 +2209,7 @@ import {
   NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
   NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider8 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider6 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
 import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2326,16 +2234,18 @@ var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
     this._stepRewards = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker3);
   }
 };
+__publicField(JsonRpcNetworkStakeViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker2);
 __publicField(JsonRpcNetworkStakeViewer, "dependencies", []);
 __publicField(JsonRpcNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker2]);
+__publicField(JsonRpcNetworkStakeViewer, "surface", "node");
 JsonRpcNetworkStakeViewer = __decorateClass([
-  creatableProvider8()
+  creatableProvider6()
 ], JsonRpcNetworkStakeViewer);
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
 import { StakeTotalsViewerMoniker as StakeTotalsViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider9 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider7 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts
 import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2370,11 +2280,13 @@ var JsonRpcStakeTotalsViewerMethods = class extends AbstractJsonRpcViewer {
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
 var JsonRpcStakeTotalsViewer = class extends JsonRpcStakeTotalsViewerMethods {
 };
+__publicField(JsonRpcStakeTotalsViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker2);
 __publicField(JsonRpcStakeTotalsViewer, "dependencies", []);
 __publicField(JsonRpcStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker2]);
+__publicField(JsonRpcStakeTotalsViewer, "surface", "node");
 JsonRpcStakeTotalsViewer = __decorateClass([
-  creatableProvider9()
+  creatableProvider7()
 ], JsonRpcStakeTotalsViewer);
 
 // src/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.ts
@@ -2382,7 +2294,7 @@ import {
   StakeEventsViewerMoniker,
   StakeViewerMoniker as StakeViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider10 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider8 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.ts
 import { StakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2434,16 +2346,18 @@ var JsonRpcStakeViewer = class extends JsonRpcStakeViewerMethods {
     return [];
   }
 };
+__publicField(JsonRpcStakeViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcStakeViewer, "defaultMoniker", StakeViewerMoniker2);
 __publicField(JsonRpcStakeViewer, "dependencies", []);
 __publicField(JsonRpcStakeViewer, "monikers", [StakeViewerMoniker2]);
+__publicField(JsonRpcStakeViewer, "surface", "node");
 JsonRpcStakeViewer = __decorateClass([
-  creatableProvider10()
+  creatableProvider8()
 ], JsonRpcStakeViewer);
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
 import { TimeSyncViewerMoniker as TimeSyncViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider11 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider9 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
 import { TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol-lib";
@@ -2469,11 +2383,13 @@ var JsonRpcTimeSyncViewerMethods = class extends AbstractJsonRpcViewer {
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
 var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
 };
+__publicField(JsonRpcTimeSyncViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcTimeSyncViewer, "defaultMoniker", TimeSyncViewerMoniker2);
 __publicField(JsonRpcTimeSyncViewer, "dependencies", []);
 __publicField(JsonRpcTimeSyncViewer, "monikers", [TimeSyncViewerMoniker2]);
+__publicField(JsonRpcTimeSyncViewer, "surface", "node");
 JsonRpcTimeSyncViewer = __decorateClass([
-  creatableProvider11()
+  creatableProvider9()
 ], JsonRpcTimeSyncViewer);
 
 // src/provider/viewer/JsonRpcTransactionViewer/JsonRpcTransactionViewer.ts
@@ -2487,7 +2403,7 @@ import {
   isTransactionBoundWitnessWithHashMeta,
   TransactionViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider10 } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
   moniker = JsonRpcTransactionViewer.defaultMoniker;
   _blockViewer;
@@ -2547,13 +2463,15 @@ var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
     return TransactionViewerRpcSchemas;
   }
 };
+__publicField(JsonRpcTransactionViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcTransactionViewer, "defaultMoniker", TransactionViewerMoniker);
 __publicField(JsonRpcTransactionViewer, "dependencies", [
   BlockViewerMoniker3
 ]);
 __publicField(JsonRpcTransactionViewer, "monikers", [TransactionViewerMoniker]);
+__publicField(JsonRpcTransactionViewer, "surface", "node");
 JsonRpcTransactionViewer = __decorateClass([
-  creatableProvider12()
+  creatableProvider10()
 ], JsonRpcTransactionViewer);
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
@@ -2561,7 +2479,7 @@ import {
   assertEx as assertEx4,
   isUndefined
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
   BlockViewerMoniker as BlockViewerMoniker4,
@@ -2576,13 +2494,13 @@ import {
   TransactionViewerMoniker as TransactionViewerMoniker2,
   XyoViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider11 } from "@xyo-network/xl1-protocol-sdk";
 async function fixSignedHydratedBlockWithHashMeta(block) {
   if (isSignedHydratedBlockWithHashMeta(block)) {
     return block;
   }
   if (isSignedHydratedBlock(block)) {
-    return [await PayloadBuilder2.addHashMeta(block[0]), await PayloadBuilder2.addHashMeta(block[1])];
+    return [await PayloadBuilder.addHashMeta(block[0]), await PayloadBuilder.addHashMeta(block[1])];
   }
   throw new Error("Invalid block format");
 }
@@ -2755,7 +2673,7 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return payloads[0] ?? null;
   }
   async payloadsByHash(hashes) {
-    return await PayloadBuilder2.addHashMeta(await this.transport.sendRequest(
+    return await PayloadBuilder.addHashMeta(await this.transport.sendRequest(
       "xyoViewer_payloadsByHash",
       [hashes]
     ));
@@ -2794,6 +2712,7 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return XyoViewerRpcSchemas;
   }
 };
+__publicField(JsonRpcXyoViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcXyoViewer, "defaultMoniker", XyoViewerMoniker);
 __publicField(JsonRpcXyoViewer, "dependencies", [
   AccountBalanceViewerMoniker3,
@@ -2807,120 +2726,12 @@ __publicField(JsonRpcXyoViewer, "dependencies", [
   TransactionViewerMoniker2
 ]);
 __publicField(JsonRpcXyoViewer, "monikers", [XyoViewerMoniker]);
+__publicField(JsonRpcXyoViewer, "surface", "node");
 JsonRpcXyoViewer = __decorateClass([
-  creatableProvider13()
+  creatableProvider11()
 ], JsonRpcXyoViewer);
 
-// src/networkTier3Descriptors.ts
-var passes = () => true;
-function rpcDescriptor(id, moniker, surface, build, planDependencies = []) {
-  return {
-    id,
-    satisfies: [moniker],
-    connectionTypes: ["rpc"],
-    dependencies: planDependencies,
-    surface,
-    preconditions: passes,
-    build
-  };
-}
-var nodeNetworkDescriptors = [
-  rpcDescriptor(
-    "JsonRpcBlockViewer",
-    JsonRpcBlockViewer.defaultMoniker,
-    "node",
-    () => JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcMempoolViewer",
-    JsonRpcMempoolViewer.defaultMoniker,
-    "node",
-    () => JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcMempoolRunner",
-    JsonRpcMempoolRunner.defaultMoniker,
-    "node",
-    () => JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcFinalizationViewer",
-    JsonRpcFinalizationViewer.defaultMoniker,
-    "node",
-    () => JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcAccountBalanceViewer",
-    JsonRpcAccountBalanceViewer.defaultMoniker,
-    "node",
-    () => JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcTransactionViewer",
-    JsonRpcTransactionViewer.defaultMoniker,
-    "node",
-    () => JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
-    [...JsonRpcTransactionViewer.dependencies]
-  ),
-  rpcDescriptor(
-    "JsonRpcTimeSyncViewer",
-    JsonRpcTimeSyncViewer.defaultMoniker,
-    "node",
-    () => JsonRpcTimeSyncViewer.factory(JsonRpcTimeSyncViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcXyoViewer",
-    JsonRpcXyoViewer.defaultMoniker,
-    "node",
-    () => JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcXyoRunner",
-    JsonRpcXyoRunner.defaultMoniker,
-    "node",
-    () => JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {}),
-    [...JsonRpcXyoRunner.dependencies]
-  ),
-  rpcDescriptor(
-    "JsonRpcStakeTotalsViewer",
-    JsonRpcStakeTotalsViewer.defaultMoniker,
-    "node",
-    () => JsonRpcStakeTotalsViewer.factory(JsonRpcStakeTotalsViewer.dependencies, {})
-  )
-];
-var indexedNetworkDescriptors = [
-  rpcDescriptor(
-    "JsonRpcStakeViewer",
-    JsonRpcStakeViewer.defaultMoniker,
-    "indexed",
-    () => JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcNetworkStakeViewer",
-    JsonRpcNetworkStakeViewer.defaultMoniker,
-    "indexed",
-    () => JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {})
-  ),
-  rpcDescriptor(
-    "JsonRpcNetworkStakeStepRewardsViewer",
-    JsonRpcNetworkStakeStepRewardsViewer.defaultMoniker,
-    "indexed",
-    () => JsonRpcNetworkStakeStepRewardsViewer.factory(
-      JsonRpcNetworkStakeStepRewardsViewer.dependencies,
-      {}
-    )
-  )
-];
-var networkTier3Descriptors = [
-  ...nodeNetworkDescriptors,
-  ...indexedNetworkDescriptors
-];
-
-// src/provider/datalake/JsonRpcDataLakeViewer.ts
-import { creatableProvider as creatableProvider14 } from "@xyo-network/xl1-protocol-sdk";
-
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
-import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var JsonRpcDataLakeViewerMethods = class _JsonRpcDataLakeViewerMethods extends AbstractJsonRpcViewer {
   static defaultMoniker = DataLakeViewerMoniker;
   static monikers = [DataLakeViewerMoniker];
@@ -2941,7 +2752,7 @@ var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
 };
 __publicField(JsonRpcDataLakeViewer, "dependencies", []);
 JsonRpcDataLakeViewer = __decorateClass([
-  creatableProvider14()
+  creatableProvider12()
 ], JsonRpcDataLakeViewer);
 
 // src/provider/permissions/RpcXyoPermissions.ts
@@ -2962,6 +2773,118 @@ var RpcXyoPermissions = class {
   }
 };
 
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
+import { MempoolRunnerMoniker as MempoolRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { elevatedTransaction, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
+
+// src/provider/runner/JsonRpcRunner.ts
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider2,
+  HttpRpcRemoteConfigZod as HttpRpcRemoteConfigZod2,
+  PostMessageRpcRemoteConfigZod as PostMessageRpcRemoteConfigZod2
+} from "@xyo-network/xl1-protocol-sdk";
+var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
+  get transport() {
+    return this.params.transport;
+  }
+  async createHandler() {
+    this.params.transport ??= this.createTransport();
+    await super.createHandler();
+  }
+  createTransport() {
+    const httpRemoteConfig = HttpRpcRemoteConfigZod2.safeParse(this.config.remote.rpc);
+    if (httpRemoteConfig.success) {
+      const { url } = httpRemoteConfig.data;
+      return new HttpRpcTransport(url, this.schemas());
+    }
+    const postMessageRemoteConfig = PostMessageRpcRemoteConfigZod2.safeParse(this.config.remote.rpc);
+    if (postMessageRemoteConfig.success) {
+      const { networkId, sessionId } = postMessageRemoteConfig.data;
+      return new PostMessageRpcTransport(networkId, this.schemas(), sessionId, this.logger);
+    }
+    throw new Error("Unable to create transport");
+  }
+};
+
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
+  moniker = MempoolRunnerMoniker;
+  async submitBlocks(blocks) {
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitBlocks",
+      [blocks]
+    );
+    return result;
+  }
+  async submitTransactions(transactions) {
+    const elevated = await Promise.all(
+      transactions.map(async ([bw, payloads]) => elevatedTransaction([
+        await PayloadBuilder2.addHashMeta(bw),
+        await PayloadBuilder2.addHashMeta(payloads)
+      ]))
+    );
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitTransactions",
+      [elevated]
+    );
+    return result;
+  }
+  schemas() {
+    return MempoolRunnerRpcSchemas;
+  }
+};
+
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
+var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
+  prunePendingBlocks(_options) {
+    throw new Error("Method not implemented.");
+  }
+  prunePendingTransactions(_options) {
+    throw new Error("Method not implemented.");
+  }
+};
+__publicField(JsonRpcMempoolRunner, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker2);
+__publicField(JsonRpcMempoolRunner, "dependencies", []);
+__publicField(JsonRpcMempoolRunner, "monikers", [MempoolRunnerMoniker2]);
+__publicField(JsonRpcMempoolRunner, "surface", "node");
+JsonRpcMempoolRunner = __decorateClass([
+  creatableProvider13()
+], JsonRpcMempoolRunner);
+
+// src/provider/runner/JsonRpcXyoRunner.ts
+import { MempoolRunnerMoniker as MempoolRunnerMoniker3, XyoRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
+import { creatableProvider as creatableProvider14 } from "@xyo-network/xl1-protocol-sdk";
+var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
+  moniker = JsonRpcXyoRunner.defaultMoniker;
+  _mempoolRunner;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  async broadcastTransaction(transaction) {
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker3);
+  }
+  schemas() {
+    return XyoRunnerRpcSchemas;
+  }
+};
+__publicField(JsonRpcXyoRunner, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
+__publicField(JsonRpcXyoRunner, "dependencies", [MempoolRunnerMoniker3]);
+__publicField(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
+__publicField(JsonRpcXyoRunner, "surface", "node");
+JsonRpcXyoRunner = __decorateClass([
+  creatableProvider14()
+], JsonRpcXyoRunner);
+
 // src/provider/signer/JsonRpcXyoSigner.ts
 import { XyoSignerMoniker as XyoSignerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 
@@ -2982,10 +2905,193 @@ var JsonRpcXyoSignerMethods = class extends AbstractJsonRpcRunner {
 
 // src/provider/signer/JsonRpcXyoSigner.ts
 var JsonRpcXyoSigner = class extends JsonRpcXyoSignerMethods {
+  static connectionTypes = ["rpc"];
   static defaultMoniker = XyoSignerMoniker2;
   static dependencies = [];
   static monikers = [XyoSignerMoniker2];
+  static surface = "node";
+};
+
+// src/engine-node/composedRpcEngineFromConnection.ts
+import {
+  JsonRpcEngineV2,
+  JsonRpcServer as JsonRpcServer2
+} from "@metamask/json-rpc-engine/v2";
+
+// src/engine-node/middleware/createHandlerMiddleware.ts
+import { createScaffoldMiddleware } from "@metamask/json-rpc-engine/v2";
+var buildHandlerScaffold = (handlers) => {
+  const scaffold = {};
+  for (const [method, handler] of Object.entries(handlers)) {
+    if (handler === void 0) continue;
+    scaffold[method] = async ({ context }) => {
+      const schema = context.assertGet("schema");
+      const params = context.assertGet("params");
+      const result = await handler(params);
+      return schema.result.to.parse(result);
+    };
+  }
+  return createScaffoldMiddleware(scaffold);
+};
+var createTypedHandlerMiddleware = (_schemas, handlers) => buildHandlerScaffold(handlers);
+
+// src/engine-node/middleware/createLoggingMiddleware.ts
+var createLoggingMiddleware = (logger) => async ({ request, next }) => {
+  try {
+    return await next();
+  } catch (error) {
+    logger?.error(`RPC ${request.method} failed`, error);
+    throw error;
+  }
 };
+
+// src/engine-node/middleware/createMethodNotFoundMiddleware.ts
+var createMethodNotFoundMiddleware = () => ({ request }) => {
+  throw new Error(`${JsonRpcErrorCodes.MethodNotFound.message} (${request.method})`);
+};
+
+// src/engine-node/middleware/createValidationMiddleware.ts
+var createValidationMiddleware = (schemas) => ({
+  request,
+  context,
+  next
+}) => {
+  const schema = schemas[request.method];
+  if (schema === void 0) return next();
+  let requestSchema = requestSchemas[request.method];
+  if (requestSchema === void 0) {
+    requestSchema = createRequestSchema(request.method, schema.params.from);
+    requestSchemas[request.method] = requestSchema;
+  }
+  const parsed = requestSchema.safeParse(request);
+  if (!parsed.success) {
+    throw new Error(parsed.error.message);
+  }
+  context.set("schema", schema);
+  context.set("params", parsed.data.params);
+  return next();
+};
+
+// src/engine-node/composedRpcEngineFromConnection.ts
+var buildTypedSubEngine = (schemas, handlers) => JsonRpcEngineV2.create({
+  middleware: [
+    createValidationMiddleware(schemas),
+    createTypedHandlerMiddleware(schemas, handlers)
+  ]
+});
+var composedRpcEngineFromConnection = (connection, logger) => {
+  const { runner, viewer } = connection;
+  const subEngines = [];
+  if (runner) {
+    subEngines.push(buildTypedSubEngine(XyoRunnerRpcSchemas, rpcMethodHandlersFromRunner(runner)));
+  }
+  if (viewer) {
+    subEngines.push(buildTypedSubEngine(XyoViewerRpcSchemas, rpcMethodHandlersFromViewer(viewer)));
+  }
+  const accountBalanceViewer = viewer?.account?.balance;
+  if (accountBalanceViewer) {
+    subEngines.push(buildTypedSubEngine(
+      AccountBalanceViewerRpcSchemas,
+      rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
+    ));
+  }
+  const blockViewer = viewer?.block;
+  if (blockViewer) {
+    subEngines.push(buildTypedSubEngine(
+      BlockViewerRpcSchemas,
+      rpcMethodHandlersFromBlockViewer(blockViewer)
+    ));
+  }
+  const finalizationViewer = viewer?.finalization;
+  if (finalizationViewer) {
+    subEngines.push(buildTypedSubEngine(
+      FinalizationViewerRpcSchemas,
+      rpcMethodHandlersFromFinalizationViewer(finalizationViewer)
+    ));
+  }
+  const mempoolViewer = viewer?.mempool;
+  if (mempoolViewer) {
+    subEngines.push(buildTypedSubEngine(
+      MempoolViewerRpcSchemas,
+      rpcMethodHandlersFromMempoolViewer(mempoolViewer)
+    ));
+  }
+  const timeSyncViewer = viewer?.time;
+  if (timeSyncViewer) {
+    subEngines.push(buildTypedSubEngine(
+      TimeSyncViewerRpcSchemas,
+      rpcMethodHandlersFromTimeSyncViewer(timeSyncViewer)
+    ));
+  }
+  const transactionViewer = viewer?.transaction;
+  if (transactionViewer) {
+    subEngines.push(buildTypedSubEngine(
+      TransactionViewerRpcSchemas,
+      rpcMethodHandlersFromTransactionViewer(transactionViewer)
+    ));
+  }
+  const mempoolRunner = runner?.mempool;
+  if (mempoolRunner) {
+    subEngines.push(buildTypedSubEngine(
+      MempoolRunnerRpcSchemas,
+      rpcMethodHandlersFromMempoolRunner(mempoolRunner)
+    ));
+  }
+  const networkStakeViewer = viewer?.networkStake;
+  if (networkStakeViewer?.stepRewards?.position) {
+    subEngines.push(buildTypedSubEngine(
+      NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+      rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
+    ));
+  }
+  const middleware = [
+    createLoggingMiddleware(logger),
+    ...subEngines.map((engine) => engine.asMiddleware()),
+    createMethodNotFoundMiddleware()
+  ];
+  return JsonRpcEngineV2.create({ middleware });
+};
+var composedRpcServerFromConnection = (connection, logger) => {
+  const engine = composedRpcEngineFromConnection(connection, logger);
+  return new JsonRpcServer2({ engine });
+};
+
+// src/engine-node/rpcEngineFromConnection.ts
+import { JsonRpcEngineV2 as JsonRpcEngineV22, JsonRpcServer as JsonRpcServer3 } from "@metamask/json-rpc-engine/v2";
+var rpcEngineFromConnection = (connection, logger) => {
+  const handlers = rpcMethodHandlersFromConnection(connection);
+  const middleware = async ({ request }) => {
+    const method = request.method;
+    const handler = handlers[method];
+    const schema = AllRpcSchemas[method];
+    if (schema === void 0 || handler === void 0) {
+      throw new Error(JsonRpcErrorCodes.MethodNotFound.message);
+    }
+    let requestSchema = requestSchemas[method];
+    if (requestSchema == void 0) {
+      requestSchema = createRequestSchema(method, schema.params.from);
+      requestSchemas[method] = requestSchema;
+    }
+    const parsed = requestSchema.safeParse(request);
+    if (!parsed.success) {
+      logger?.error("RPC Request Validation Error", parsed.error);
+      throw new Error(parsed.error.message);
+    }
+    const { params } = parsed.data;
+    try {
+      const result = await handler(params);
+      return schema.result.to.parse(result);
+    } catch (error) {
+      logger?.error("RPC Response Handler Error", error);
+      throw error;
+    }
+  };
+  return JsonRpcEngineV22.create({ middleware: [middleware] });
+};
+function rpcServerFromConnection(connection, logger) {
+  const engine = rpcEngineFromConnection(connection, logger);
+  return new JsonRpcServer3({ engine });
+}
 export {
   AbstractJsonRpcRunner,
   AbstractJsonRpcViewer,
@@ -3056,16 +3162,20 @@ export {
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
+  composedRpcEngineFromConnection,
+  composedRpcServerFromConnection,
+  createLoggingMiddleware,
+  createMethodNotFoundMiddleware,
   createRequestSchema,
   createResponseSchema,
+  createTypedHandlerMiddleware,
+  createValidationMiddleware,
   hasSessionId,
-  indexedNetworkDescriptors,
   isEventWithId,
   isMessageWithId,
   jsonrpc,
-  networkTier3Descriptors,
-  nodeNetworkDescriptors,
   requestSchemas,
+  rpcEngineFromConnection,
   rpcMethodHandlersFromAccountBalanceViewer,
   rpcMethodHandlersFromBlockViewer,
   rpcMethodHandlersFromConnection,
@@ -3080,6 +3190,7 @@ export {
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
   rpcMethodHandlersFromTransactionViewer,
-  rpcMethodHandlersFromViewer
+  rpcMethodHandlersFromViewer,
+  rpcServerFromConnection
 };
 //# sourceMappingURL=index.mjs.map