@xyo-network/xl1-rpc 2.1.8 → 2.2.0

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
@@ -1669,7 +1813,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 +1828,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) {
@@ -2543,17 +2687,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;
@@ -3087,8 +3231,14 @@ export {
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
+  composedRpcEngineFromConnection,
+  composedRpcServerFromConnection,
+  createLoggingMiddleware,
+  createMethodNotFoundMiddleware,
   createRequestSchema,
   createResponseSchema,
+  createTypedHandlerMiddleware,
+  createValidationMiddleware,
   hasSessionId,
   indexedNetworkDescriptors,
   isEventWithId,
@@ -3111,6 +3261,7 @@ export {
   rpcMethodHandlersFromRunner,
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
+  rpcMethodHandlersFromTransactionViewer,
   rpcMethodHandlersFromViewer,
   rpcServerFromConnection
 };