@xyo-network/xl1-rpc 3.0.1 → 3.0.2

package/dist/neutral/index.mjs

@@ -2911,6 +2911,187 @@ var JsonRpcXyoSigner = class extends JsonRpcXyoSignerMethods {
   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,
@@ -2981,13 +3162,20 @@ export {
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
+  composedRpcEngineFromConnection,
+  composedRpcServerFromConnection,
+  createLoggingMiddleware,
+  createMethodNotFoundMiddleware,
   createRequestSchema,
   createResponseSchema,
+  createTypedHandlerMiddleware,
+  createValidationMiddleware,
   hasSessionId,
   isEventWithId,
   isMessageWithId,
   jsonrpc,
   requestSchemas,
+  rpcEngineFromConnection,
   rpcMethodHandlersFromAccountBalanceViewer,
   rpcMethodHandlersFromBlockViewer,
   rpcMethodHandlersFromConnection,
@@ -3002,6 +3190,7 @@ export {
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
   rpcMethodHandlersFromTransactionViewer,
-  rpcMethodHandlersFromViewer
+  rpcMethodHandlersFromViewer,
+  rpcServerFromConnection
 };
 //# sourceMappingURL=index.mjs.map