@xyo-network/xl1-rpc 2.1.9 → 2.2.1

package/dist/node/index-node.mjs

@@ -222,8 +222,11 @@ var rpcMethodHandlersFromSigner = (signer) => {
   };
 };
 
-// src/engine-node/rpcEngineFromConnection.ts
-import { JsonRpcEngineV2, JsonRpcServer } from "@metamask/json-rpc-engine/v2";
+// src/engine-node/composedRpcEngineFromConnection.ts
+import {
+  JsonRpcEngineV2,
+  JsonRpcServer
+} from "@metamask/json-rpc-engine/v2";
 
 // src/types/DataLakePageRpc.ts
 var DataLakesPageMethodPrefix = "xyoDataLakes";
@@ -262,7 +265,7 @@ var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsView
 
 // src/types/schema/AccountBalanceViewerRpcSchemas.ts
 import { BigIntToJsonZod, JsonToBigIntZod } from "@xylabs/sdk-js";
-import { XyoAddressZod } from "@xyo-network/address";
+import { XyoAddressZod } from "@xyo-network/sdk-js";
 import {
   AccountBalanceHistoryItemZod,
   ChainQualifiedConfigZod,
@@ -294,9 +297,10 @@ var AccountBalanceViewerRpcSchemas = {
 
 // src/types/schema/BlockViewerRpcSchemas.ts
 import { HashZod } from "@xylabs/sdk-js";
-import { PayloadZod, WithHashMetaZod } from "@xyo-network/sdk-js";
+import { HashMetaZod, PayloadZodLoose } from "@xyo-network/sdk-js";
 import { SignedHydratedBlockWithHashMetaZod, XL1BlockNumberZod } from "@xyo-network/xl1-protocol-lib";
 import { z as z2 } from "zod/mini";
+var WithHashMetaPayloadZodLoose = z2.extend(PayloadZodLoose, HashMetaZod.shape);
 var BlockViewerRpcSchemas = {
   blockViewer_blocksByNumber: {
     params: {
@@ -344,15 +348,15 @@ var BlockViewerRpcSchemas = {
       from: z2.tuple([z2.array(HashZod)])
     },
     result: {
-      to: z2.array(z2.looseObject(WithHashMetaZod(PayloadZod).shape)),
-      from: z2.array(z2.looseObject(WithHashMetaZod(PayloadZod).shape))
+      to: z2.array(WithHashMetaPayloadZodLoose),
+      from: z2.array(WithHashMetaPayloadZodLoose)
     }
   }
 };
 
 // src/types/schema/DataLakeViewerRpcSchema.ts
 import { HashZod as HashZod2 } from "@xylabs/sdk-js";
-import { PayloadZod as PayloadZod2 } from "@xyo-network/sdk-js";
+import { PayloadZod } from "@xyo-network/sdk-js";
 import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol-lib";
 import { z as z3 } from "zod/mini";
 var DataLakeViewerRpcSchemas = {
@@ -362,8 +366,8 @@ var DataLakeViewerRpcSchemas = {
       from: z3.tuple([z3.array(HashZod2)])
     },
     result: {
-      to: z3.array(z3.union([z3.looseObject(PayloadZod2.shape), ArrayBufferToJsonZod])),
-      from: z3.array(z3.union([z3.looseObject(PayloadZod2.shape), JsonToArrayBufferZod]))
+      to: z3.array(z3.union([z3.looseObject(PayloadZod.shape), ArrayBufferToJsonZod])),
+      from: z3.array(z3.union([z3.looseObject(PayloadZod.shape), JsonToArrayBufferZod]))
     }
   },
   dataLakeViewer_next: {
@@ -372,8 +376,8 @@ var DataLakeViewerRpcSchemas = {
       from: z3.tuple([z3.looseObject({})])
     },
     result: {
-      to: z3.array(z3.union([z3.looseObject(PayloadZod2.shape), ArrayBufferToJsonZod])),
-      from: z3.array(z3.union([z3.looseObject(PayloadZod2.shape), JsonToArrayBufferZod]))
+      to: z3.array(z3.union([z3.looseObject(PayloadZod.shape), ArrayBufferToJsonZod])),
+      from: z3.array(z3.union([z3.looseObject(PayloadZod.shape), JsonToArrayBufferZod]))
     }
   }
 };
@@ -528,7 +532,7 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
-import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/address";
+import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
 import { asAttoXL1 as asAttoXL12, RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol-lib";
 import { z as z9 } from "zod/mini";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
@@ -586,7 +590,7 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
-import { XyoAddressZod as XyoAddressZod3 } from "@xyo-network/address";
+import { XyoAddressZod as XyoAddressZod3 } from "@xyo-network/sdk-js";
 import { asAttoXL1 as asAttoXL13, RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol-lib";
 import { z as z10 } from "zod/mini";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
@@ -701,7 +705,7 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
 
 // src/types/schema/StakeTotalsViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
-import { XyoAddressZod as XyoAddressZod4 } from "@xyo-network/address";
+import { XyoAddressZod as XyoAddressZod4 } from "@xyo-network/sdk-js";
 import { asAttoXL1 as asAttoXL15 } from "@xyo-network/xl1-protocol-lib";
 import { z as z12 } from "zod/mini";
 var StakeTotalsViewerRpcSchemas = {
@@ -778,7 +782,7 @@ var StakeTotalsViewerRpcSchemas = {
 };
 
 // src/types/schema/StakeViewerRpcSchemas.ts
-import { XyoAddressZod as XyoAddressZod5 } from "@xyo-network/address";
+import { XyoAddressZod as XyoAddressZod5 } from "@xyo-network/sdk-js";
 import { JsonToStakeZod, StakeToJsonZod } from "@xyo-network/xl1-protocol-lib";
 import { z as z14 } from "zod";
 
@@ -995,28 +999,6 @@ import { HashZod as HashZod4 } from "@xylabs/sdk-js";
 import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2 } from "@xyo-network/xl1-protocol-lib";
 import { z as z17 } from "zod/mini";
 var TransactionViewerRpcSchemas = {
-  /** @deprecated use byBlockHashAndIndex instead */
-  transactionViewer_transactionByBlockHashAndIndex: {
-    params: {
-      to: z17.tuple([HashZod4, z17.number()]),
-      from: z17.tuple([HashZod4, z17.number()])
-    },
-    result: {
-      to: z17.nullable(SignedHydratedTransactionWithHashMetaZod2),
-      from: z17.nullable(SignedHydratedTransactionWithHashMetaZod2)
-    }
-  },
-  /** @deprecated use byBlockNumberAndIndex instead */
-  transactionViewer_transactionByBlockNumberAndIndex: {
-    params: {
-      to: z17.tuple([z17.number(), z17.number()]),
-      from: z17.tuple([z17.number(), z17.number()])
-    },
-    result: {
-      to: z17.nullable(SignedHydratedTransactionWithHashMetaZod2),
-      from: z17.nullable(SignedHydratedTransactionWithHashMetaZod2)
-    }
-  },
   transactionViewer_byHash: {
     params: {
       to: z17.tuple([HashZod4]),
@@ -1026,17 +1008,6 @@ var TransactionViewerRpcSchemas = {
       to: z17.nullable(SignedHydratedTransactionWithHashMetaZod2),
       from: z17.nullable(SignedHydratedTransactionWithHashMetaZod2)
     }
-  },
-  /** @deprecated use byHash instead */
-  transactionViewer_transactionByHash: {
-    params: {
-      to: z17.tuple([HashZod4]),
-      from: z17.tuple([HashZod4])
-    },
-    result: {
-      to: z17.nullable(SignedHydratedTransactionWithHashMetaZod2),
-      from: z17.nullable(SignedHydratedTransactionWithHashMetaZod2)
-    }
   }
 };
 
@@ -1098,7 +1069,7 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { XyoAddressZod as XyoAddressZod6 } from "@xyo-network/address";
+import { XyoAddressZod as XyoAddressZod6 } from "@xyo-network/sdk-js";
 import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod3, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol-lib";
 import { z as z20 } from "zod";
 var XyoSignerRpcSchemas = {
@@ -1131,11 +1102,11 @@ import {
   HexZod,
   JsonToBigIntZod as JsonToBigIntZod9
 } from "@xylabs/sdk-js";
-import { XyoAddressZod as XyoAddressZod7 } from "@xyo-network/address";
-import { PayloadZodLoose } from "@xyo-network/sdk-js";
+import { PayloadZodLoose as PayloadZodLoose2, XyoAddressZod as XyoAddressZod7 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2,
   asAttoXL1 as asAttoXL16,
+  ChainQualifiedConfigZod as ChainQualifiedConfigZod2,
   JsonToStakeZod as JsonToStakeZod3,
   SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod4,
   SignedHydratedTransactionZod as SignedHydratedTransactionZod3,
@@ -1145,6 +1116,29 @@ import {
   XL1BlockRangeZod
 } from "@xyo-network/xl1-protocol-lib";
 import { z as z21 } from "zod/mini";
+var accountBalanceParamsFrom = z21.union([
+  z21.pipe(
+    z21.tuple([XyoAddressZod7]),
+    z21.transform(([addr]) => [addr])
+  ),
+  z21.pipe(
+    z21.tuple([XyoAddressZod7, HashZod5]),
+    z21.transform(([addr, head]) => [addr, { head }])
+  ),
+  z21.pipe(
+    z21.tuple([XyoAddressZod7, XL1BlockRangeZod]),
+    z21.transform(([addr, range]) => [addr, { range }])
+  )
+]);
+var accountBalanceParamsTo = z21.pipe(
+  z21.tuple([XyoAddressZod7, z21.optional(ChainQualifiedConfigZod2)]),
+  z21.transform(([addr, config]) => {
+    if (config === void 0) return [addr];
+    if ("head" in config) return [addr, config.head];
+    if ("range" in config) return [addr, config.range];
+    return [addr];
+  })
+);
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
@@ -1326,20 +1320,31 @@ var XyoViewerRpcSchemas = {
       from: z21.record(z21.string(), z21.tuple([z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))), z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))]))
     }
   },
+  // params bridge between the positional wire format and the object-form
+  // in-memory shape the viewer expects:
+  //   wire:      `[Address] | [Address, Hash | [BlockNum, BlockNum]]`
+  //   in-memory: `[Address, ChainQualifiedConfig?]`
+  //              (ChainQualifiedConfig = {head} | {range} | {})
+  // `from` (wire → in-memory, server-side) wraps the bare hash/range in the
+  // {head} / {range} object; `to` (in-memory → wire, client-side) unwraps.
+  // The wire format itself is unchanged — existing positional callers keep
+  // working — but the handler now receives the object form the viewer
+  // implementation can actually qualify on.
   xyoViewer_accountBalance: {
     params: {
-      to: z21.union([z21.tuple([XyoAddressZod7]), z21.tuple([XyoAddressZod7, z21.union([XL1BlockRangeZod, HashZod5])])]),
-      from: z21.union([z21.tuple([XyoAddressZod7]), z21.tuple([XyoAddressZod7, z21.union([XL1BlockRangeZod, HashZod5])])])
+      to: accountBalanceParamsTo,
+      from: accountBalanceParamsFrom
     },
     result: {
       to: BigIntToJsonZod9,
       from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
     }
   },
+  // Same wire-vs-in-memory params bridge as `xyoViewer_accountBalance`.
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z21.union([z21.tuple([XyoAddressZod7]), z21.tuple([XyoAddressZod7, z21.union([XL1BlockRangeZod, HashZod5])])]),
-      from: z21.union([z21.tuple([XyoAddressZod7]), z21.tuple([XyoAddressZod7, z21.union([XL1BlockRangeZod, HashZod5])])])
+      to: accountBalanceParamsTo,
+      from: accountBalanceParamsFrom
     },
     result: {
       to: z21.array(AccountBalanceHistoryItemZod2),
@@ -1472,8 +1477,8 @@ var XyoViewerRpcSchemas = {
       from: z21.tuple([z21.array(HashZod5)])
     },
     result: {
-      to: z21.array(PayloadZodLoose),
-      from: z21.array(PayloadZodLoose)
+      to: z21.array(PayloadZodLoose2),
+      from: z21.array(PayloadZodLoose2)
     }
   }
 };
@@ -1522,7 +1527,7 @@ var createResponseSchema = (resultSchema = z23.undefined()) => z23.object({
 
 // src/types/schema/DataLakePageRpcSchemas.ts
 import { HashZod as HashZod6 } from "@xylabs/sdk-js";
-import { PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/sdk-js";
+import { PayloadZodLoose as PayloadZodLoose3 } from "@xyo-network/sdk-js";
 import { ArrayBufferToJsonZod as ArrayBufferToJsonZod2, JsonToArrayBufferZod as JsonToArrayBufferWideZod } from "@xyo-network/xl1-protocol-model";
 import { z as z24 } from "zod";
 var JsonToArrayBufferZod2 = JsonToArrayBufferWideZod.pipe(z24.instanceof(ArrayBuffer));
@@ -1533,8 +1538,8 @@ var DataLakePageRpcSchemas = {
       from: z24.tuple([z24.object({ id: z24.string(), hashes: z24.array(HashZod6) })])
     },
     result: {
-      to: z24.array(z24.union([PayloadZodLoose2, ArrayBufferToJsonZod2])),
-      from: z24.array(z24.union([PayloadZodLoose2, JsonToArrayBufferZod2]))
+      to: z24.array(z24.union([PayloadZodLoose3, ArrayBufferToJsonZod2])),
+      from: z24.array(z24.union([PayloadZodLoose3, JsonToArrayBufferZod2]))
     }
   },
   xyoDataLakes_insert: {
@@ -1542,24 +1547,163 @@ var DataLakePageRpcSchemas = {
       to: z24.tuple([
         z24.object({
           id: z24.string(),
-          payloads: z24.array(z24.union([PayloadZodLoose2, ArrayBufferToJsonZod2]))
+          payloads: z24.array(z24.union([PayloadZodLoose3, ArrayBufferToJsonZod2]))
         })
       ]),
       from: z24.tuple([
         z24.object({
           id: z24.string(),
-          payloads: z24.array(z24.union([PayloadZodLoose2, JsonToArrayBufferZod2]))
+          payloads: z24.array(z24.union([PayloadZodLoose3, JsonToArrayBufferZod2]))
         })
       ])
     },
     result: {
-      to: z24.array(z24.union([PayloadZodLoose2, ArrayBufferToJsonZod2])),
-      from: z24.array(z24.union([PayloadZodLoose2, JsonToArrayBufferZod2]))
+      to: z24.array(z24.union([PayloadZodLoose3, ArrayBufferToJsonZod2])),
+      from: z24.array(z24.union([PayloadZodLoose3, JsonToArrayBufferZod2]))
     }
   }
 };
 
+// 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 }) => {
@@ -1588,11 +1732,11 @@ var rpcEngineFromConnection = (connection, logger) => {
       throw error;
     }
   };
-  return JsonRpcEngineV2.create({ middleware: [middleware] });
+  return JsonRpcEngineV22.create({ middleware: [middleware] });
 };
 function rpcServerFromConnection(connection, logger) {
   const engine = rpcEngineFromConnection(connection, logger);
-  return new JsonRpcServer({ engine });
+  return new JsonRpcServer2({ engine });
 }
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
@@ -1641,14 +1785,15 @@ var HttpRpcTransport = class {
         method
       };
       const schema = schemas[method];
-      if (params) {
+      if (params !== void 0) {
         body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z25.json().parse(params) : void 0;
         if (!isDefined(body.params)) {
           throw new Error(`[callRpc] RPC method ${String(method)} missing schema`);
         }
       }
       body.params ??= [];
-      const res = await new FetchJsonClient().post(url, body);
+      const client = new FetchJsonClient();
+      const res = await client.post(url, body);
       const json = res.data;
       if (isUndefinedOrNull(json)) {
         throw new Error(`[callRpc] empty response body (status ${res.status})`);
@@ -1669,7 +1814,7 @@ var HttpRpcTransport = class {
 };
 
 // src/transport/MemoryRpcTransport.ts
-import { JsonRpcServer as JsonRpcServer2 } from "@metamask/json-rpc-engine/v2";
+import { JsonRpcServer as JsonRpcServer3 } from "@metamask/json-rpc-engine/v2";
 import {
   assertEx,
   isObject,
@@ -1684,7 +1829,7 @@ var MemoryRpcTransport = class {
   responseSchemas = {};
   constructor(rpcEngine, schemas) {
     this._rpcEngine = rpcEngine;
-    this._rpcServer = new JsonRpcServer2({ engine: rpcEngine });
+    this._rpcServer = new JsonRpcServer3({ engine: rpcEngine });
     this._schemas = schemas;
   }
   async sendRequest(method, params) {
@@ -1755,22 +1900,33 @@ var isMessageWithId = (message) => {
 };
 
 // src/transport/PostMessage/bus/implementations/PostMessage.ts
+function browserWindow() {
+  return globalThis;
+}
+function deliverPostMessage(message, targetOrigin, transfer) {
+  const win = browserWindow();
+  if (typeof win.postMessage !== "function") {
+    throw new TypeError("postMessage is only available in browser environments");
+  }
+  const postMessageFn = win.postMessage;
+  postMessageFn.call(win, message, targetOrigin, transfer);
+}
 var PostMessageBus = class extends AbstractMessageBus {
   constructor(sessionId, name = "default") {
     super(sessionId, name);
   }
-  postMessage(message, origin = globalThis.location.origin) {
-    globalThis.postMessage(message, origin);
+  postMessage(message, origin) {
+    deliverPostMessage(message, origin ?? browserWindow().location?.origin ?? "*");
   }
   start() {
-    globalThis.addEventListener("message", (event) => this.handleMessage(event));
+    addEventListener("message", (event) => this.handleMessage(event));
   }
   stop() {
-    globalThis.removeEventListener("message", this.handleMessage);
+    removeEventListener("message", this.handleMessage);
     this.connections.length = 0;
   }
   handleMessage = (event) => {
-    if (event.origin !== globalThis.location.origin) return;
+    if (event.origin !== browserWindow().location?.origin) return;
     if (!this.validateSessionId(event.data?.sessionId)) return;
     for (const connection of this.connections) {
       const { id, listener } = connection;
@@ -1831,20 +1987,21 @@ var PostMessageRpcTransport = class {
       const postMessageBus = new PostMessageBus(this.sessionId);
       const postMessageConnection = {
         listener: (event) => {
-          if ("data" in event.data && isJsonRpcResponse(event.data.data)) {
-            const response = event.data.data;
-            if (isJsonRpcSuccess(response) && Array.isArray(response.result)) {
-              const ret = schemas[method].result.from.parse(response.result[0]);
-              resolve(ret);
-              return;
-            }
-            if (isJsonRpcFailure(response)) {
-              this.logger?.error("Error in PostMessageRpcTransport", response);
-              reject(new Error(response.error.message));
-              return;
-            }
-            throw new Error(`Invalid response from wallet extension, ${JSON.stringify(event.data)}`);
+          if (!("data" in event.data) || !isJsonRpcResponse(event.data.data)) {
+            return;
           }
+          const response = event.data.data;
+          if (isJsonRpcSuccess(response) && Array.isArray(response.result)) {
+            const ret = schemas[method].result.from.parse(response.result[0]);
+            resolve(ret);
+            return;
+          }
+          if (isJsonRpcFailure(response)) {
+            this.logger?.error("Error in PostMessageRpcTransport", response);
+            reject(new Error(response.error.message));
+            return;
+          }
+          throw new Error(`Invalid response from wallet extension, ${JSON.stringify(event.data)}`);
         },
         id
       };
@@ -2107,25 +2264,32 @@ var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
     };
   }
   async blockByHash(hash) {
-    return (await this.blocksByHash(hash, 1))[0];
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
   }
   async blockByNumber(block) {
-    return (await this.blocksByNumber(block, 1))[0];
+    const blocks = await this.blocksByNumber(block, 1);
+    return blocks[0];
   }
   async chainId(blockNumber = "latest") {
     if (blockNumber === "latest") {
-      return (await this.currentBlock())[0].chain;
+      const current = await this.currentBlock();
+      return current[0].chain;
     }
-    return (await this.blocksByNumber(blockNumber, 1))[0][0].chain;
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0][0].chain;
   }
   async currentBlockHash() {
-    return (await this.currentBlock())[0]._hash;
+    const block = await this.currentBlock();
+    return block[0]._hash;
   }
   async currentBlockNumber() {
-    return (await this.currentBlock())[0].block;
+    const block = await this.currentBlock();
+    return block[0].block;
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([hash]))[0] ?? null;
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
   }
   async rate(range, timeUnit) {
     return await calculateBlockRate(this, range, timeUnit);
@@ -2177,10 +2341,11 @@ var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
     }, this.headPollIntervalMs);
   }
   stopHeadPolling() {
-    if (this._headPollTimer) {
-      clearInterval(this._headPollTimer);
-      this._headPollTimer = null;
+    if (!this._headPollTimer) {
+      return;
     }
+    clearInterval(this._headPollTimer);
+    this._headPollTimer = null;
   }
 };
 __publicField(JsonRpcBlockViewer, "defaultMoniker", BlockViewerMoniker2);
@@ -2213,16 +2378,20 @@ var JsonRpcFinalizationViewerMethods = class extends AbstractJsonRpcViewer {
 // src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
 var JsonRpcFinalizationViewer = class extends JsonRpcFinalizationViewerMethods {
   async chainId() {
-    return (await this.headBlock()).chain;
+    const headBlock = await this.headBlock();
+    return headBlock.chain;
   }
   async headBlock() {
-    return (await this.head())[0];
+    const head = await this.head();
+    return head[0];
   }
   async headHash() {
-    return (await this.head())[0]._hash;
+    const head = await this.head();
+    return head[0]._hash;
   }
   async headNumber() {
-    return (await this.head())[0].block;
+    const head = await this.head();
+    return head[0].block;
   }
 };
 __publicField(JsonRpcFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker2);
@@ -2543,17 +2712,17 @@ var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
     await super.createHandler();
     this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
   }
+  /** @deprecated Use {@link byBlockHashAndIndex} — this routes there. */
   async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
-    const result = await this.transport.sendRequest("transactionViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
-    return result ?? null;
+    return await this.byBlockHashAndIndex(blockHash, transactionIndex);
   }
+  /** @deprecated Use {@link byBlockNumberAndIndex} — this routes there. */
   async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
-    const result = await this.transport.sendRequest("transactionViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
-    return result ?? null;
+    return await this.byBlockNumberAndIndex(blockNumber, transactionIndex);
   }
+  /** @deprecated Use {@link byHash} — this routes there. */
   async transactionByHash(transactionHash) {
-    const result = await this.transport.sendRequest("transactionViewer_transactionByHash", [transactionHash]);
-    return result ?? null;
+    return await this.byHash(transactionHash);
   }
   schemas() {
     return TransactionViewerRpcSchemas;
@@ -2639,28 +2808,33 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return await this.account.balance.accountBalanceHistory(address, config);
   }
   async blockByHash(hash) {
-    return (await this.blocksByHash(hash, 1))[0];
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
   }
   async blockByNumber(blockNumber) {
-    return (await this.blocksByNumber(blockNumber, 1))[0];
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0];
   }
   async blocksByHash(hash, limit) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByHash",
       [hash, limit]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async blocksByNumber(blockNumber, limit) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByNumber",
       [blockNumber, limit]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async blocksByStep(stepLevel, stepIndex) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByStep",
       [stepLevel, stepIndex]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async chainId(blockNumber = "latest") {
     const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
@@ -2693,10 +2867,12 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return fixSignedHydratedBlockWithHashMeta(result);
   }
   async currentBlockHash() {
-    return (await this.currentBlock())[0]._hash;
+    const block = await this.currentBlock();
+    return block[0]._hash;
   }
   async currentBlockNumber() {
-    return (await this.currentBlock())[0].block;
+    const block = await this.currentBlock();
+    return block[0].block;
   }
   async forkHistory() {
     return await this.transport.sendRequest("xyoViewer_forkHistory");
@@ -2756,7 +2932,8 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForStepLevel", [stepLevel, range]);
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([hash]))[0] ?? null;
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
   }
   async payloadsByHash(hashes) {
     return await PayloadBuilder2.addHashMeta(await this.transport.sendRequest(
@@ -3087,8 +3264,14 @@ export {
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
+  composedRpcEngineFromConnection,
+  composedRpcServerFromConnection,
+  createLoggingMiddleware,
+  createMethodNotFoundMiddleware,
   createRequestSchema,
   createResponseSchema,
+  createTypedHandlerMiddleware,
+  createValidationMiddleware,
   hasSessionId,
   indexedNetworkDescriptors,
   isEventWithId,
@@ -3111,6 +3294,7 @@ export {
   rpcMethodHandlersFromRunner,
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
+  rpcMethodHandlersFromTransactionViewer,
   rpcMethodHandlersFromViewer,
   rpcServerFromConnection
 };