@xyo-network/xl1-rpc 2.1.9 → 2.2.0

package/dist/neutral/engine/index.d.ts

@@ -12,5 +12,6 @@ export * from './rpcMethodHandlersFromPermissions.ts';
 export * from './rpcMethodHandlersFromRunner.ts';
 export * from './rpcMethodHandlersFromSigner.ts';
 export * from './rpcMethodHandlersFromTimeSyncViewer.ts';
+export * from './rpcMethodHandlersFromTransactionViewer.ts';
 export * from './rpcMethodHandlersFromViewer.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/engine/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gDAAgD,CAAA;AAC9D,cAAc,uCAAuC,CAAA;AACrD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,yCAAyC,CAAA;AACvD,cAAc,mEAAmE,CAAA;AACjF,cAAc,qEAAqE,CAAA;AACnF,cAAc,gDAAgD,CAAA;AAC9D,cAAc,uCAAuC,CAAA;AACrD,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,0CAA0C,CAAA;AACxD,cAAc,kCAAkC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gDAAgD,CAAA;AAC9D,cAAc,uCAAuC,CAAA;AACrD,cAAc,sCAAsC,CAAA;AACpD,cAAc,8CAA8C,CAAA;AAC5D,cAAc,yCAAyC,CAAA;AACvD,cAAc,yCAAyC,CAAA;AACvD,cAAc,mEAAmE,CAAA;AACjF,cAAc,qEAAqE,CAAA;AACnF,cAAc,gDAAgD,CAAA;AAC9D,cAAc,uCAAuC,CAAA;AACrD,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,0CAA0C,CAAA;AACxD,cAAc,6CAA6C,CAAA;AAC3D,cAAc,kCAAkC,CAAA"}

package/dist/neutral/engine-node/composedRpcEngineFromConnection.d.ts

@@ -0,0 +1,20 @@
+import type { JsonRpcRequest } from '@metamask/json-rpc-engine/v2';
+import { JsonRpcEngineV2, JsonRpcServer } from '@metamask/json-rpc-engine/v2';
+import type { Logger } from '@xylabs/sdk-js';
+import type { XyoConnection } from '@xyo-network/xl1-protocol-lib';
+import type { RpcContext, RpcMiddleware } from './middleware/index.ts';
+/**
+ * Composed alternative to {@link rpcEngineFromConnection}. Builds the same
+ * engine surface, but as a stack of small middleware:
+ *
+ *   logging → [sub-engine per viewer/runner namespace] → method-not-found
+ *
+ * Each sub-engine pairs a {@link createValidationMiddleware} with a
+ * {@link createTypedHandlerMiddleware}, isolating one viewer's schemas + handlers.
+ * Cross-cutting concerns (logging, error mapping, future auth/rate-limit) live
+ * once at the root rather than inside the dispatch loop.
+ */
+export declare const composedRpcEngineFromConnection: (connection: XyoConnection, logger?: Logger) => JsonRpcEngineV2<JsonRpcRequest, RpcContext>;
+/** Convenience wrapper that returns a spec-compliant {@link JsonRpcServer}. */
+export declare const composedRpcServerFromConnection: (connection: XyoConnection, logger?: Logger) => JsonRpcServer<RpcMiddleware>;
+//# sourceMappingURL=composedRpcEngineFromConnection.d.ts.map

package/dist/neutral/engine-node/composedRpcEngineFromConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composedRpcEngineFromConnection.d.ts","sourceRoot":"","sources":["../../../src/engine-node/composedRpcEngineFromConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,EACL,eAAe,EACf,aAAa,EACd,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AA2BlE,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EAEd,MAAM,uBAAuB,CAAA;AA6B9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,GAC1C,YAAY,aAAa,EACzB,SAAS,MAAM,KAEd,eAAe,CAAC,cAAc,EAAE,UAAU,CAkF5C,CAAA;AAED,+EAA+E;AAC/E,eAAO,MAAM,+BAA+B,GAC1C,YAAY,aAAa,EACzB,SAAS,MAAM,KACd,aAAa,CAAC,aAAa,CAG7B,CAAA"}

package/dist/neutral/engine-node/index.d.ts

@@ -1,2 +1,4 @@
+export * from './composedRpcEngineFromConnection.ts';
+export * from './middleware/index.ts';
 export * from './rpcEngineFromConnection.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/engine-node/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine-node/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine-node/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA;AACpD,cAAc,uBAAuB,CAAA;AACrC,cAAc,8BAA8B,CAAA"}

package/dist/neutral/engine-node/middleware/RpcContext.d.ts

@@ -0,0 +1,25 @@
+import type { Json, JsonRpcMiddleware, JsonRpcRequest, MiddlewareContext } from '@metamask/json-rpc-engine/v2';
+import type { RequestResponseSchemas } from '../../types/index.ts';
+/**
+ * Keys that validation middleware stamps into the per-request context.
+ *
+ * Must be a type alias (not an interface): `MiddlewareContext<K>` constrains
+ * `K extends Record<PropertyKey, unknown>`, which interfaces can't satisfy
+ * because they're open to declaration merging.
+ */
+export type RpcContextKeyValues = {
+    /** Pre-validated, deserialized params; safe for handlers to consume. */
+    params: unknown;
+    /** The schema entry for the dispatched method; used to encode the result. */
+    schema: RequestResponseSchemas;
+};
+/** Typed MiddlewareContext used throughout the RPC engine. */
+export type RpcContext = MiddlewareContext<RpcContextKeyValues>;
+/**
+ * Middleware shape used throughout the RPC engine. We only handle
+ * {@link JsonRpcRequest}s (no notifications), so Result is constrained to
+ * {@link Json}. This matches what `createScaffoldMiddleware` and a sub-engine
+ * built purely from request-handling middleware will produce.
+ */
+export type RpcMiddleware = JsonRpcMiddleware<JsonRpcRequest, Json, RpcContext>;
+//# sourceMappingURL=RpcContext.d.ts.map

package/dist/neutral/engine-node/middleware/RpcContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcContext.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/RpcContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EAClB,MAAM,8BAA8B,CAAA;AAErC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAElE;;;;;;GAMG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAChC,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAA;IACf,6EAA6E;IAC7E,MAAM,EAAE,sBAAsB,CAAA;CAC/B,CAAA;AAED,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC,mBAAmB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,iBAAiB,CAAC,cAAc,EAAE,IAAI,EAAE,UAAU,CAAC,CAAA"}

package/dist/neutral/engine-node/middleware/createHandlerMiddleware.d.ts

@@ -0,0 +1,38 @@
+import type { Promisable } from '@xylabs/sdk-js';
+import type { z } from 'zod/mini';
+import type { RpcSchemaMap } from '../../types/index.ts';
+import type { RpcMiddleware } from './RpcContext.ts';
+/**
+ * Handler record whose signatures are derived directly from a schema map.
+ *
+ *   params:  `z.output<params.from>` — the in-memory shape that
+ *            `params.from` produces by parsing the wire request on the
+ *            server. This is what the handler actually receives.
+ *
+ *   result:  `z.input<result.to>` — the in-memory shape the handler
+ *            returns, which `result.to` then encodes for the wire. For
+ *            schemas without a `.transform()`, `z.input` and `z.output`
+ *            are identical; for transform pipes (e.g. `BigIntToJsonZod`
+ *            mapping `bigint` → `BrandedHex`) they diverge, and the
+ *            handler must produce the pre-transform `bigint`/AttoXL1.
+ *
+ * A schema change forces a corresponding handler update (and vice versa).
+ *
+ * @example
+ *   const handlers: TypedRpcHandlerRecord<typeof FinalizationViewerRpcSchemas> = {
+ *     finalizationViewer_head: () => viewer.head(),
+ *   }
+ */
+export type TypedRpcHandlerRecord<TSchemas extends RpcSchemaMap> = {
+    [K in keyof TSchemas]: (params: z.output<TSchemas[K]['params']['from']>) => Promisable<z.input<TSchemas[K]['result']['to']>>;
+};
+/**
+ * Builds a scaffold middleware that dispatches by method name to the matching
+ * handler. `handlers` is constrained at the type level against `TSchemas` so
+ * adding/removing/retyping a method in the schema map forces a corresponding
+ * handler update (and vice versa). The `schemas` runtime argument exists only
+ * to drive type inference — it's not consumed at runtime; each request's
+ * schema entry is read from `MiddlewareContext` after upstream validation.
+ */
+export declare const createTypedHandlerMiddleware: <TSchemas extends RpcSchemaMap>(_schemas: TSchemas, handlers: TypedRpcHandlerRecord<TSchemas>) => RpcMiddleware;
+//# sourceMappingURL=createHandlerMiddleware.d.ts.map

package/dist/neutral/engine-node/middleware/createHandlerMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHandlerMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/createHandlerMiddleware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,iBAAiB,CAAA;AA8BhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,qBAAqB,CAAC,QAAQ,SAAS,YAAY,IAAI;KAChE,CAAC,IAAI,MAAM,QAAQ,GAAG,CACrB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAC5C,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;CACtD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ,SAAS,YAAY,EACxE,UAAU,QAAQ,EAClB,UAAU,qBAAqB,CAAC,QAAQ,CAAC,KACxC,aAA+C,CAAA"}

package/dist/neutral/engine-node/middleware/createLoggingMiddleware.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '@xylabs/sdk-js';
+import type { RpcMiddleware } from './RpcContext.ts';
+/**
+ * Wraps downstream middleware in a try/catch and logs any thrown error
+ * with the offending RPC method name. Re-throws so JsonRpcServer can
+ * still format a spec-compliant error response.
+ */
+export declare const createLoggingMiddleware: (logger?: Logger) => RpcMiddleware;
+//# sourceMappingURL=createLoggingMiddleware.d.ts.map

package/dist/neutral/engine-node/middleware/createLoggingMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLoggingMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/createLoggingMiddleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,KAAG,aAOzD,CAAA"}

package/dist/neutral/engine-node/middleware/createMethodNotFoundMiddleware.d.ts

@@ -0,0 +1,7 @@
+import type { RpcMiddleware } from './RpcContext.ts';
+/**
+ * Terminal middleware. Reached only when no sibling middleware/sub-engine
+ * matched the request method; throws a JSON-RPC "method not found" error.
+ */
+export declare const createMethodNotFoundMiddleware: () => RpcMiddleware;
+//# sourceMappingURL=createMethodNotFoundMiddleware.d.ts.map

package/dist/neutral/engine-node/middleware/createMethodNotFoundMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMethodNotFoundMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/createMethodNotFoundMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAO,aAEjD,CAAA"}

package/dist/neutral/engine-node/middleware/createValidationMiddleware.d.ts

@@ -0,0 +1,10 @@
+import type { RpcSchemaMap } from '../../types/index.ts';
+import type { RpcMiddleware } from './RpcContext.ts';
+/**
+ * Validates the request against the matching Zod schema in `schemas`, then
+ * stamps `params` and `schema` into the MiddlewareContext for downstream
+ * handlers. If the method is not in `schemas`, the request is passed through
+ * via `next()` — letting a sibling sub-engine or terminal middleware handle it.
+ */
+export declare const createValidationMiddleware: (schemas: RpcSchemaMap) => RpcMiddleware;
+//# sourceMappingURL=createValidationMiddleware.d.ts.map

package/dist/neutral/engine-node/middleware/createValidationMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createValidationMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/createValidationMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,YAAY,KAAG,aAoBlE,CAAA"}

package/dist/neutral/engine-node/middleware/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createHandlerMiddleware.ts';
+export * from './createLoggingMiddleware.ts';
+export * from './createMethodNotFoundMiddleware.ts';
+export * from './createValidationMiddleware.ts';
+export * from './RpcContext.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/engine-node/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/engine-node/middleware/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iBAAiB,CAAA"}

package/dist/neutral/index.mjs

@@ -267,7 +267,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,
@@ -299,9 +299,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: {
@@ -349,15 +350,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 = {
@@ -367,8 +368,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: {
@@ -377,8 +378,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]))
     }
   }
 };
@@ -533,7 +534,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 = {
@@ -591,7 +592,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 = {
@@ -706,7 +707,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 = {
@@ -783,7 +784,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";
 
@@ -1000,28 +1001,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]),
@@ -1031,17 +1010,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)
-    }
   }
 };
 
@@ -1103,7 +1071,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 = {
@@ -1136,11 +1104,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,
@@ -1150,6 +1118,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: {
@@ -1331,20 +1322,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),
@@ -1477,8 +1479,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)
     }
   }
 };
@@ -1527,7 +1529,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));
@@ -1538,8 +1540,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: {
@@ -1547,19 +1549,19 @@ 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]))
     }
   }
 };
@@ -2504,17 +2506,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;
@@ -3071,6 +3073,7 @@ export {
   rpcMethodHandlersFromRunner,
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
+  rpcMethodHandlersFromTransactionViewer,
   rpcMethodHandlersFromViewer
 };
 //# sourceMappingURL=index.mjs.map