@xyo-network/xl1-rpc 3.0.0 → 3.0.2

package/dist/{node/index-node.mjs → neutral/client/index.mjs}

@@ -222,11 +222,11 @@ var rpcMethodHandlersFromSigner = (signer) => {
   };
 };
 
-// src/engine-node/composedRpcEngineFromConnection.ts
-import {
-  JsonRpcEngineV2,
-  JsonRpcServer
-} from "@metamask/json-rpc-engine/v2";
+// src/provider/datalake/JsonRpcDataLakeViewer.ts
+import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 
 // src/types/DataLakePageRpc.ts
 var DataLakesPageMethodPrefix = "xyoDataLakes";
@@ -1564,190 +1564,14 @@ var DataLakePageRpcSchemas = {
   }
 };
 
-// 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 JsonRpcServer({ engine });
-};
-
-// src/engine-node/rpcEngineFromConnection.ts
-import { JsonRpcEngineV2 as JsonRpcEngineV22, JsonRpcServer as JsonRpcServer2 } 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 JsonRpcServer2({ engine });
-}
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-import { MempoolRunnerMoniker as MempoolRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
+// 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/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
-import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { elevatedTransaction, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 
-// src/provider/runner/JsonRpcRunner.ts
+// src/provider/viewer/JsonRpcViewer.ts
 import {
   AbstractCreatableProvider,
   HttpRpcRemoteConfigZod,
@@ -1814,7 +1638,7 @@ var HttpRpcTransport = class {
 };
 
 // src/transport/MemoryRpcTransport.ts
-import { JsonRpcServer as JsonRpcServer3 } from "@metamask/json-rpc-engine/v2";
+import { JsonRpcServer } from "@metamask/json-rpc-engine/v2";
 import {
   assertEx,
   isObject,
@@ -1829,7 +1653,7 @@ var MemoryRpcTransport = class {
   responseSchemas = {};
   constructor(rpcEngine, schemas) {
     this._rpcEngine = rpcEngine;
-    this._rpcServer = new JsonRpcServer3({ engine: rpcEngine });
+    this._rpcServer = new JsonRpcServer({ engine: rpcEngine });
     this._schemas = schemas;
   }
   async sendRequest(method, params) {
@@ -2016,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;
@@ -2134,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);
@@ -2187,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
@@ -2201,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
@@ -2348,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";
@@ -2394,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";
@@ -2431,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";
@@ -2468,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 {
 };
@@ -2482,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";
@@ -2507,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";
@@ -2551,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
@@ -2563,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";
@@ -2615,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";
@@ -2650,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
@@ -2668,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;
@@ -2728,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
@@ -2742,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,
@@ -2757,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");
 }
@@ -2936,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]
     ));
@@ -2975,6 +2712,7 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return XyoViewerRpcSchemas;
   }
 };
+__publicField(JsonRpcXyoViewer, "connectionTypes", ["rpc"]);
 __publicField(JsonRpcXyoViewer, "defaultMoniker", XyoViewerMoniker);
 __publicField(JsonRpcXyoViewer, "dependencies", [
   AccountBalanceViewerMoniker3,
@@ -2988,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];
@@ -3122,7 +2752,7 @@ var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
 };
 __publicField(JsonRpcDataLakeViewer, "dependencies", []);
 JsonRpcDataLakeViewer = __decorateClass([
-  creatableProvider14()
+  creatableProvider12()
 ], JsonRpcDataLakeViewer);
 
 // src/provider/permissions/RpcXyoPermissions.ts
@@ -3143,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";
 
@@ -3163,9 +2905,11 @@ 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";
 };
 export {
   AbstractJsonRpcRunner,
@@ -3237,23 +2981,13 @@ export {
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
-  composedRpcEngineFromConnection,
-  composedRpcServerFromConnection,
-  createLoggingMiddleware,
-  createMethodNotFoundMiddleware,
   createRequestSchema,
   createResponseSchema,
-  createTypedHandlerMiddleware,
-  createValidationMiddleware,
   hasSessionId,
-  indexedNetworkDescriptors,
   isEventWithId,
   isMessageWithId,
   jsonrpc,
-  networkTier3Descriptors,
-  nodeNetworkDescriptors,
   requestSchemas,
-  rpcEngineFromConnection,
   rpcMethodHandlersFromAccountBalanceViewer,
   rpcMethodHandlersFromBlockViewer,
   rpcMethodHandlersFromConnection,
@@ -3268,7 +3002,6 @@ export {
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
   rpcMethodHandlersFromTransactionViewer,
-  rpcMethodHandlersFromViewer,
-  rpcServerFromConnection
+  rpcMethodHandlersFromViewer
 };
-//# sourceMappingURL=index-node.mjs.map
+//# sourceMappingURL=index.mjs.map