@xyo-network/xl1-rpc 2.1.9 → 2.2.1

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]))
     }
   }
 };
@@ -1602,14 +1604,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})`);
@@ -1716,22 +1719,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;
@@ -1792,20 +1806,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
       };
@@ -2068,25 +2083,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);
@@ -2138,10 +2160,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);
@@ -2174,16 +2197,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);
@@ -2504,17 +2531,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;
@@ -2600,28 +2627,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);
@@ -2654,10 +2686,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");
@@ -2717,7 +2751,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(
@@ -3071,6 +3106,7 @@ export {
   rpcMethodHandlersFromRunner,
   rpcMethodHandlersFromSigner,
   rpcMethodHandlersFromTimeSyncViewer,
+  rpcMethodHandlersFromTransactionViewer,
   rpcMethodHandlersFromViewer
 };
 //# sourceMappingURL=index.mjs.map