@xyo-network/xl1-sdk 4.0.11 → 4.0.12

package/dist/neutral/rpc.mjs

@@ -0,0 +1,3150 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/modules/rpc/engine/requestSchemas.ts
+var requestSchemas = {};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromAccountBalanceViewer.ts
+var rpcMethodHandlersFromAccountBalanceViewer = (viewer) => {
+  return {
+    accountBalanceViewer_qualifiedAccountBalances: (params) => viewer.qualifiedAccountBalances(...params ?? []),
+    accountBalanceViewer_qualifiedAccountBalanceHistories: (params) => viewer.qualifiedAccountBalanceHistories(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromBlockViewer.ts
+var rpcMethodHandlersFromBlockViewer = (viewer) => {
+  return {
+    blockViewer_blocksByHash: (params) => viewer.blocksByHash(...params ?? []),
+    blockViewer_blocksByNumber: (params) => viewer.blocksByNumber(...params ?? []),
+    blockViewer_blocksByStep: (params) => viewer.blocksByStep(...params ?? []),
+    blockViewer_currentBlock: (params) => viewer.currentBlock(...params ?? []),
+    blockViewer_payloadsByHash: (params) => viewer.payloadsByHash(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromFinalizationViewer.ts
+var rpcMethodHandlersFromFinalizationViewer = (viewer) => {
+  return { finalizationViewer_head: (params) => viewer.head(...params ?? []) };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromMempoolRunner.ts
+var rpcMethodHandlersFromMempoolRunner = (runner) => {
+  return {
+    mempoolRunner_submitBlocks: (params) => runner.submitBlocks(...params ?? []),
+    mempoolRunner_submitTransactions: (params) => runner.submitTransactions(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromMempoolViewer.ts
+var rpcMethodHandlersFromMempoolViewer = (viewer) => {
+  return {
+    mempoolViewer_pendingBlocks: (params) => viewer.pendingBlocks(...params ?? []),
+    mempoolViewer_pendingTransactions: (params) => viewer.pendingTransactions(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
+var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = (viewer) => {
+  return {
+    networkStakingStepRewardsByPositionViewer_bonus: (params) => viewer.bonus(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_claimed: (params) => viewer.claimed(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_earned: (params) => viewer.earned(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_total: (params) => viewer.total(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_unclaimed: (params) => viewer.unclaimed(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromRunner.ts
+var rpcMethodHandlersFromRunner = (runner) => {
+  return { xyoRunner_broadcastTransaction: (params) => runner.broadcastTransaction(...params ?? []) };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromTimeSyncViewer.ts
+var rpcMethodHandlersFromTimeSyncViewer = (viewer) => {
+  return {
+    timeSyncViewer_convertTime: (params) => viewer.convertTime(...params ?? []),
+    timeSyncViewer_currentTime: (params) => viewer.currentTime(...params ?? []),
+    timeSyncViewer_currentTimeAndHash: (params) => viewer.currentTimeAndHash(...params ?? []),
+    timeSyncViewer_currentTimePayload: (params) => viewer.currentTimePayload(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromTransactionViewer.ts
+var rpcMethodHandlersFromTransactionViewer = (viewer) => {
+  return { transactionViewer_byHash: (params) => viewer.byHash(...params ?? []) };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromViewer.ts
+var rpcMethodHandlersFromViewer = (viewer) => {
+  return {
+    xyoViewer_networkStakeStepRewardClaimedByAddress: (params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressReward: (params) => viewer.networkStakeStepRewardAddressReward(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressHistory: (params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressShare: (params) => viewer.networkStakeStepRewardAddressShare(...params ?? []),
+    xyoViewer_networkStakeStepRewardWeightForAddress: (params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardUnclaimedByAddress: (params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []),
+    xyoViewer_networkStakeStepRewardPoolShares: (params) => viewer.networkStakeStepRewardPoolShares(...params ?? []),
+    xyoViewer_networkStakeStepRewardPoolRewards: (params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []),
+    xyoViewer_networkStakeStepRewardPositionWeight: (params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardPotentialPositionLoss: (params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForStep: (params) => viewer.networkStakeStepRewardForStep?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardRandomizer: (params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardStakerCount: (params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForStepForPosition: (params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForPosition: (params) => viewer.networkStakeStepRewardForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForPosition: (params) => viewer.networkStakeStepRewardsForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForRange: (params) => viewer.networkStakeStepRewardsForRange?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForStepLevel: (params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []),
+    xyoViewer_blocksByNumber: (params) => viewer.blocksByNumber(...params ?? []),
+    xyoViewer_blocksByHash: (params) => viewer.blocksByHash(...params ?? []),
+    xyoViewer_blocksByStep: (params) => viewer.blocksByStep(...params ?? []),
+    xyoViewer_currentBlock: (params) => viewer.currentBlock(...params ?? []),
+    xyoViewer_forkHistory: (params) => viewer.forkHistory(...params ?? []),
+    xyoViewer_stakeById: (params) => viewer.stakeById(...params ?? []),
+    xyoViewer_stakeByStaker: (params) => viewer.stakeByStaker(...params ?? []),
+    xyoViewer_stakesByStaked: (params) => viewer.stakesByStaked(...params ?? []),
+    xyoViewer_stakesByStaker: (params) => viewer.stakesByStaker(...params ?? []),
+    xyoViewer_transactionByBlockHashAndIndex: (params) => viewer.transaction.byBlockHashAndIndex(...params ?? []),
+    xyoViewer_transactionByBlockNumberAndIndex: (params) => viewer.transaction.byBlockNumberAndIndex(...params ?? []),
+    xyoViewer_transactionByHash: (params) => viewer.transaction.byHash(...params ?? []),
+    xyoViewer_payloadsByHash: (params) => viewer.payloadsByHash(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromConnection.ts
+var rpcMethodHandlersFromConnection = (connection) => {
+  const { runner, viewer } = connection;
+  let result = {};
+  if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) };
+  if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) };
+  const accountBalanceViewer = viewer?.account?.balance;
+  if (accountBalanceViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
+    };
+  }
+  const blockViewer = viewer?.block;
+  if (blockViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromBlockViewer(blockViewer)
+    };
+  }
+  const finalizationViewer = viewer?.finalization;
+  if (finalizationViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromFinalizationViewer(finalizationViewer)
+    };
+  }
+  const mempoolViewer = viewer?.mempool;
+  if (mempoolViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromMempoolViewer(mempoolViewer)
+    };
+  }
+  const timeSyncViewer = viewer?.time;
+  if (timeSyncViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromTimeSyncViewer(timeSyncViewer)
+    };
+  }
+  const transactionViewer = viewer?.transaction;
+  if (transactionViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromTransactionViewer(transactionViewer)
+    };
+  }
+  const mempoolRunner = runner?.mempool;
+  if (mempoolRunner) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromMempoolRunner(mempoolRunner)
+    };
+  }
+  const networkStakeViewer = viewer?.networkStake;
+  if (networkStakeViewer?.stepRewards?.position) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
+    };
+  }
+  return result;
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer.ts
+var rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer = (viewer) => {
+  return {
+    networkStakingStepRewardsByPositionViewer_bonus: (params) => viewer.bonus(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_claimed: (params) => viewer.claimed(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_earned: (params) => viewer.earned(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_total: (params) => viewer.total(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_unclaimed: (params) => viewer.unclaimed(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromNetworkStakingViewer.ts
+var rpcMethodHandlersFromNetworkStakingViewer = (viewer) => {
+  return { networkStakeViewer_active: (params) => viewer.active(...params ?? []) };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromPermissions.ts
+var rpcMethodHandlersFromPermissions = (permissions) => {
+  return {
+    xyoPermissions_getPermissions: (params) => permissions.getPermissions(...params ?? []),
+    xyoPermissions_requestPermissions: (params) => permissions.requestPermissions(...params ?? []),
+    xyoPermissions_revokePermissions: (params) => permissions.revokePermissions(...params ?? [])
+  };
+};
+
+// src/modules/rpc/engine/rpcMethodHandlersFromSigner.ts
+var rpcMethodHandlersFromSigner = (signer) => {
+  return {
+    xyoSigner_address: (params) => signer.address(...params ?? []),
+    xyoSigner_sign: (params) => signer.sign(...params ?? [])
+  };
+};
+
+// src/modules/rpc/provider/datalake/JsonRpcDataLakeViewer.ts
+import { creatableProvider as creatableProvider12 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+
+// src/modules/rpc/types/DataLakePageRpc.ts
+var DataLakesPageMethodPrefix = "xyoDataLakes";
+var DataLakesGetMethod = `${DataLakesPageMethodPrefix}_get`;
+var DataLakesInsertMethod = `${DataLakesPageMethodPrefix}_insert`;
+
+// src/modules/rpc/types/ErrorCodes.ts
+var JsonRpcErrorCodes = {
+  InternalError: { code: -32603, message: "Internal JSON-RPC error (unexpected exception)." },
+  InvalidParams: { code: -32602, message: "Invalid method parameter(s)." },
+  InvalidRequest: { code: -32600, message: "The JSON sent is not a valid Request object." },
+  MethodNotFound: { code: -32601, message: "The method does not exist or is not available." },
+  UserRejected: { code: 4001, message: "User rejected the request." }
+};
+
+// src/modules/rpc/types/JsonRpc.ts
+var jsonrpc = "2.0";
+
+// src/modules/rpc/types/NetworkStakeViewerRpc.ts
+var NetworkStakeViewerRpcNamespace = "networkStakeViewer";
+
+// src/modules/rpc/types/NetworkStakingStepRewardsByPositionViewerRpc.ts
+var NetworkStakingStepRewardsByPositionViewerRpcNamespace = "networkStakingStepRewardsByPositionViewer";
+
+// src/modules/rpc/types/NetworkStakingStepRewardsByStakerViewerRpc.ts
+var NetworkStakingStepRewardsByStakerViewerRpcNamespace = "networkStakingStepRewardsByStakerViewer";
+
+// src/modules/rpc/types/NetworkStakingStepRewardsByStepViewerRpc.ts
+var NetworkStakingStepRewardsByStepViewerRpcNamespace = "networkStakingStepRewardsByStepViewer";
+
+// src/modules/rpc/types/NetworkStakingStepRewardsTotalViewerRpc.ts
+var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepRewardsTotalViewer";
+
+// src/modules/rpc/types/NetworkStakingStepRewardsViewerRpc.ts
+var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
+
+// src/modules/rpc/types/schema/AccountBalanceViewerRpcSchemas.ts
+import { BigIntToJsonZod, JsonToBigIntZod } from "@ariestools/sdk";
+import { XyoAddressZod } from "@xyo-network/sdk";
+import {
+  AccountBalanceHistoryItemZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedZod
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { z } from "zod";
+var AccountBalanceViewerRpcSchemas = {
+  accountBalanceViewer_qualifiedAccountBalances: {
+    params: {
+      to: z.tuple([z.array(XyoAddressZod), ChainQualifiedConfigZod]),
+      from: z.tuple([z.array(XyoAddressZod), ChainQualifiedConfigZod])
+    },
+    result: {
+      to: ChainQualifiedZod(z.record(XyoAddressZod, BigIntToJsonZod)),
+      from: ChainQualifiedZod(z.record(XyoAddressZod, JsonToBigIntZod))
+    }
+  },
+  accountBalanceViewer_qualifiedAccountBalanceHistories: {
+    params: {
+      to: z.tuple([z.array(XyoAddressZod), ChainQualifiedConfigZod]),
+      from: z.tuple([z.array(XyoAddressZod), ChainQualifiedConfigZod])
+    },
+    result: {
+      to: ChainQualifiedZod(z.record(XyoAddressZod, z.array(AccountBalanceHistoryItemZod))),
+      from: ChainQualifiedZod(z.record(XyoAddressZod, z.array(AccountBalanceHistoryItemZod)))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/BlockViewerRpcSchemas.ts
+import { HashZod } from "@ariestools/sdk";
+import { HashMetaZod, PayloadZodLoose } from "@xyo-network/sdk";
+import { SignedHydratedBlockWithHashMetaZod, XL1BlockNumberZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z2 } from "zod/mini";
+var WithHashMetaPayloadZodLoose = z2.extend(PayloadZodLoose, HashMetaZod.shape);
+var BlockViewerRpcSchemas = {
+  blockViewer_blocksByNumber: {
+    params: {
+      to: z2.tuple([XL1BlockNumberZod, z2.optional(z2.number())]),
+      from: z2.tuple([XL1BlockNumberZod, z2.optional(z2.number())])
+    },
+    result: {
+      to: z2.array(SignedHydratedBlockWithHashMetaZod),
+      from: z2.array(SignedHydratedBlockWithHashMetaZod)
+    }
+  },
+  blockViewer_blocksByHash: {
+    params: {
+      to: z2.tuple([HashZod, z2.optional(z2.number())]),
+      from: z2.tuple([HashZod, z2.optional(z2.number())])
+    },
+    result: {
+      to: z2.array(SignedHydratedBlockWithHashMetaZod),
+      from: z2.array(SignedHydratedBlockWithHashMetaZod)
+    }
+  },
+  blockViewer_blocksByStep: {
+    params: {
+      to: z2.tuple([z2.number(), z2.number()]),
+      from: z2.tuple([z2.number(), z2.number()])
+    },
+    result: {
+      to: z2.array(SignedHydratedBlockWithHashMetaZod),
+      from: z2.array(SignedHydratedBlockWithHashMetaZod)
+    }
+  },
+  blockViewer_currentBlock: {
+    params: {
+      to: z2._default(z2.tuple([]), []),
+      from: z2._default(z2.tuple([]), [])
+    },
+    result: {
+      to: SignedHydratedBlockWithHashMetaZod,
+      from: SignedHydratedBlockWithHashMetaZod
+    }
+  },
+  blockViewer_payloadsByHash: {
+    params: {
+      to: z2.tuple([z2.array(HashZod)]),
+      from: z2.tuple([z2.array(HashZod)])
+    },
+    result: {
+      to: z2.array(WithHashMetaPayloadZodLoose),
+      from: z2.array(WithHashMetaPayloadZodLoose)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/DataLakeViewerRpcSchema.ts
+import { HashZod as HashZod2 } from "@ariestools/sdk";
+import { PayloadZod } from "@xyo-network/sdk";
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z3 } from "zod/mini";
+var DataLakeViewerRpcSchemas = {
+  dataLakeViewer_get: {
+    params: {
+      to: z3.tuple([z3.array(HashZod2)]),
+      from: z3.tuple([z3.array(HashZod2)])
+    },
+    result: {
+      to: z3.array(z3.union([z3.looseObject(PayloadZod.shape), ArrayBufferToJsonZod])),
+      from: z3.array(z3.union([z3.looseObject(PayloadZod.shape), JsonToArrayBufferZod]))
+    }
+  },
+  dataLakeViewer_next: {
+    params: {
+      to: z3.tuple([z3.looseObject({})]),
+      from: z3.tuple([z3.looseObject({})])
+    },
+    result: {
+      to: z3.array(z3.union([z3.looseObject(PayloadZod.shape), ArrayBufferToJsonZod])),
+      from: z3.array(z3.union([z3.looseObject(PayloadZod.shape), JsonToArrayBufferZod]))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/FinalizationViewerRpcSchemas.ts
+import { SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z4 } from "zod";
+var FinalizationViewerRpcSchemas = {
+  finalizationViewer_head: {
+    params: {
+      to: z4.tuple([]).default([]),
+      from: z4.tuple([]).default([])
+    },
+    result: {
+      to: SignedHydratedBlockWithHashMetaZod2,
+      from: SignedHydratedBlockWithHashMetaZod2
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/MempoolRunnerRpcSchemas.ts
+import { HashZod as HashZod3 } from "@ariestools/sdk";
+import { SignedHydratedBlockZod, SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z5 } from "zod";
+var MempoolRunnerRpcSchemas = {
+  mempoolRunner_submitBlocks: {
+    params: {
+      to: z5.tuple([z5.array(SignedHydratedBlockZod)]),
+      from: z5.tuple([z5.array(SignedHydratedBlockZod)])
+    },
+    result: {
+      to: z5.array(HashZod3),
+      from: z5.array(HashZod3)
+    }
+  },
+  mempoolRunner_submitTransactions: {
+    params: {
+      to: z5.tuple([z5.array(SignedHydratedTransactionZod)]),
+      from: z5.tuple([z5.array(SignedHydratedTransactionZod)])
+    },
+    result: {
+      to: z5.array(HashZod3),
+      from: z5.array(HashZod3)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/MempoolViewerRpcSchemas.ts
+import {
+  PendingBlocksOptionsZod,
+  PendingTransactionsOptionsZod,
+  SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3,
+  SignedHydratedTransactionWithHashMetaZod
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z6 } from "zod/mini";
+var MempoolViewerRpcSchemas = {
+  mempoolViewer_pendingBlocks: {
+    params: {
+      to: z6.tuple([z6.optional(PendingBlocksOptionsZod)]),
+      from: z6.tuple([z6.optional(PendingBlocksOptionsZod)])
+    },
+    result: {
+      to: z6.array(SignedHydratedBlockWithHashMetaZod3),
+      from: z6.array(SignedHydratedBlockWithHashMetaZod3)
+    }
+  },
+  mempoolViewer_pendingTransactions: {
+    params: {
+      to: z6.tuple([z6.optional(PendingTransactionsOptionsZod)]),
+      from: z6.tuple([z6.optional(PendingTransactionsOptionsZod)])
+    },
+    result: {
+      to: z6.array(SignedHydratedTransactionWithHashMetaZod),
+      from: z6.array(SignedHydratedTransactionWithHashMetaZod)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/NetworkStakeViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@ariestools/sdk";
+import { BlockNumberZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z7 } from "zod";
+var NetworkStakeViewerRpcSchemas = {
+  networkStakeViewer_active: {
+    params: {
+      to: z7.tuple([BlockNumberZod.optional()]),
+      from: z7.tuple([BlockNumberZod.optional()])
+    },
+    result: {
+      to: z7.tuple([BigIntToJsonZod2, z7.number()]),
+      from: z7.tuple([JsonToBigIntZod2, z7.number()])
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/RewardsByPositionViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod3 } from "@ariestools/sdk";
+import { asAttoXL1, RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z8 } from "zod/mini";
+var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
+  networkStakingStepRewardsByPositionViewer_bonus: {
+    params: {
+      to: z8.tuple([z8.optional(RewardsRangeOptionsZod)]),
+      from: z8.tuple([z8.optional(RewardsRangeOptionsZod)])
+    },
+    result: {
+      to: z8.record(z8.number(), BigIntToJsonZod3),
+      from: z8.record(z8.number(), z8.pipe(JsonToBigIntZod3, z8.transform((val) => asAttoXL1(val))))
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_claimed: {
+    params: {
+      to: z8.tuple([z8.optional(RewardsRangeOptionsZod)]),
+      from: z8.tuple([z8.optional(RewardsRangeOptionsZod)])
+    },
+    result: {
+      to: z8.record(z8.number(), BigIntToJsonZod3),
+      from: z8.record(z8.number(), z8.pipe(JsonToBigIntZod3, z8.transform((val) => asAttoXL1(val))))
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_earned: {
+    params: {
+      to: z8.tuple([z8.optional(RewardsRangeOptionsZod)]),
+      from: z8.tuple([z8.optional(RewardsRangeOptionsZod)])
+    },
+    result: {
+      to: z8.record(z8.number(), BigIntToJsonZod3),
+      from: z8.record(z8.number(), z8.pipe(JsonToBigIntZod3, z8.transform((val) => asAttoXL1(val))))
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_total: {
+    params: {
+      to: z8.tuple([z8.optional(RewardsRangeOptionsZod)]),
+      from: z8.tuple([z8.optional(RewardsRangeOptionsZod)])
+    },
+    result: {
+      to: z8.record(z8.number(), BigIntToJsonZod3),
+      from: z8.record(z8.number(), z8.pipe(JsonToBigIntZod3, z8.transform((val) => asAttoXL1(val))))
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_unclaimed: {
+    params: {
+      to: z8.tuple([z8.optional(RewardsRangeOptionsZod)]),
+      from: z8.tuple([z8.optional(RewardsRangeOptionsZod)])
+    },
+    result: {
+      to: z8.record(z8.number(), BigIntToJsonZod3),
+      from: z8.record(z8.number(), z8.pipe(JsonToBigIntZod3, z8.transform((val) => asAttoXL1(val))))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/RewardsByStakerViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@ariestools/sdk";
+import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk";
+import { asAttoXL1 as asAttoXL12, RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z9 } from "zod/mini";
+var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
+  networkStakingStepRewardsByStakerViewer_bonus: {
+    params: {
+      to: z9.tuple([z9.optional(RewardsRangeOptionsZod2)]),
+      from: z9.tuple([z9.optional(RewardsRangeOptionsZod2)])
+    },
+    result: {
+      to: z9.record(XyoAddressZod2, BigIntToJsonZod4),
+      from: z9.record(XyoAddressZod2, z9.pipe(JsonToBigIntZod4, z9.transform((val) => asAttoXL12(val))))
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_claimed: {
+    params: {
+      to: z9.tuple([z9.optional(RewardsRangeOptionsZod2)]),
+      from: z9.tuple([z9.optional(RewardsRangeOptionsZod2)])
+    },
+    result: {
+      to: z9.record(XyoAddressZod2, BigIntToJsonZod4),
+      from: z9.record(XyoAddressZod2, z9.pipe(JsonToBigIntZod4, z9.transform((val) => asAttoXL12(val))))
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_earned: {
+    params: {
+      to: z9.tuple([z9.optional(RewardsRangeOptionsZod2)]),
+      from: z9.tuple([z9.optional(RewardsRangeOptionsZod2)])
+    },
+    result: {
+      to: z9.record(XyoAddressZod2, BigIntToJsonZod4),
+      from: z9.record(XyoAddressZod2, z9.pipe(JsonToBigIntZod4, z9.transform((val) => asAttoXL12(val))))
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_total: {
+    params: {
+      to: z9.tuple([z9.optional(RewardsRangeOptionsZod2)]),
+      from: z9.tuple([z9.optional(RewardsRangeOptionsZod2)])
+    },
+    result: {
+      to: z9.record(XyoAddressZod2, BigIntToJsonZod4),
+      from: z9.record(XyoAddressZod2, z9.pipe(JsonToBigIntZod4, z9.transform((val) => asAttoXL12(val))))
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_unclaimed: {
+    params: {
+      to: z9.tuple([z9.optional(RewardsRangeOptionsZod2)]),
+      from: z9.tuple([z9.optional(RewardsRangeOptionsZod2)])
+    },
+    result: {
+      to: z9.record(XyoAddressZod2, BigIntToJsonZod4),
+      from: z9.record(XyoAddressZod2, z9.pipe(JsonToBigIntZod4, z9.transform((val) => asAttoXL12(val))))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/RewardsByStepViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@ariestools/sdk";
+import { XyoAddressZod as XyoAddressZod3 } from "@xyo-network/sdk";
+import { asAttoXL1 as asAttoXL13, RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z10 } from "zod/mini";
+var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
+  networkStakingStepRewardsByStepViewer_bonus: {
+    params: {
+      to: z10.tuple([z10.optional(RewardsRangeOptionsZod3)]),
+      from: z10.tuple([z10.optional(RewardsRangeOptionsZod3)])
+    },
+    result: {
+      to: z10.record(XyoAddressZod3, BigIntToJsonZod5),
+      from: z10.record(XyoAddressZod3, z10.pipe(JsonToBigIntZod5, z10.transform((val) => asAttoXL13(val))))
+    }
+  },
+  networkStakingStepRewardsByStepViewer_claimed: {
+    params: {
+      to: z10.tuple([z10.optional(RewardsRangeOptionsZod3)]),
+      from: z10.tuple([z10.optional(RewardsRangeOptionsZod3)])
+    },
+    result: {
+      to: z10.record(XyoAddressZod3, BigIntToJsonZod5),
+      from: z10.record(XyoAddressZod3, z10.pipe(JsonToBigIntZod5, z10.transform((val) => asAttoXL13(val))))
+    }
+  },
+  networkStakingStepRewardsByStepViewer_earned: {
+    params: {
+      to: z10.tuple([z10.optional(RewardsRangeOptionsZod3)]),
+      from: z10.tuple([z10.optional(RewardsRangeOptionsZod3)])
+    },
+    result: {
+      to: z10.record(XyoAddressZod3, BigIntToJsonZod5),
+      from: z10.record(XyoAddressZod3, z10.pipe(JsonToBigIntZod5, z10.transform((val) => asAttoXL13(val))))
+    }
+  },
+  networkStakingStepRewardsByStepViewer_total: {
+    params: {
+      to: z10.tuple([z10.optional(RewardsRangeOptionsZod3)]),
+      from: z10.tuple([z10.optional(RewardsRangeOptionsZod3)])
+    },
+    result: {
+      to: z10.record(XyoAddressZod3, BigIntToJsonZod5),
+      from: z10.record(XyoAddressZod3, z10.pipe(JsonToBigIntZod5, z10.transform((val) => asAttoXL13(val))))
+    }
+  },
+  networkStakingStepRewardsByStepViewer_unclaimed: {
+    params: {
+      to: z10.tuple([z10.optional(RewardsRangeOptionsZod3)]),
+      from: z10.tuple([z10.optional(RewardsRangeOptionsZod3)])
+    },
+    result: {
+      to: z10.record(XyoAddressZod3, BigIntToJsonZod5),
+      from: z10.record(XyoAddressZod3, z10.pipe(JsonToBigIntZod5, z10.transform((val) => asAttoXL13(val))))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/RewardsTotalViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@ariestools/sdk";
+import { asAttoXL1 as asAttoXL14, RewardsRangeOptionsZod as RewardsRangeOptionsZod4 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z11 } from "zod/mini";
+var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
+  networkStakingStepRewardsTotalViewer_bonus: {
+    params: {
+      to: z11.tuple([z11.optional(RewardsRangeOptionsZod4)]),
+      from: z11.tuple([z11.optional(RewardsRangeOptionsZod4)])
+    },
+    result: {
+      to: BigIntToJsonZod6,
+      from: z11.pipe(JsonToBigIntZod6, z11.transform((val) => asAttoXL14(val)))
+    }
+  },
+  networkStakingStepRewardsTotalViewer_claimed: {
+    params: {
+      to: z11.tuple([z11.optional(RewardsRangeOptionsZod4)]),
+      from: z11.tuple([z11.optional(RewardsRangeOptionsZod4)])
+    },
+    result: {
+      to: BigIntToJsonZod6,
+      from: z11.pipe(JsonToBigIntZod6, z11.transform((val) => asAttoXL14(val)))
+    }
+  },
+  networkStakingStepRewardsTotalViewer_earned: {
+    params: {
+      to: z11.tuple([z11.optional(RewardsRangeOptionsZod4)]),
+      from: z11.tuple([z11.optional(RewardsRangeOptionsZod4)])
+    },
+    result: {
+      to: BigIntToJsonZod6,
+      from: z11.pipe(JsonToBigIntZod6, z11.transform((val) => asAttoXL14(val)))
+    }
+  },
+  networkStakingStepRewardsTotalViewer_total: {
+    params: {
+      to: z11.tuple([z11.optional(RewardsRangeOptionsZod4)]),
+      from: z11.tuple([z11.optional(RewardsRangeOptionsZod4)])
+    },
+    result: {
+      to: BigIntToJsonZod6,
+      from: z11.pipe(JsonToBigIntZod6, z11.transform((val) => asAttoXL14(val)))
+    }
+  },
+  networkStakingStepRewardsTotalViewer_unclaimed: {
+    params: {
+      to: z11.tuple([z11.optional(RewardsRangeOptionsZod4)]),
+      from: z11.tuple([z11.optional(RewardsRangeOptionsZod4)])
+    },
+    result: {
+      to: BigIntToJsonZod6,
+      from: z11.pipe(JsonToBigIntZod6, z11.transform((val) => asAttoXL14(val)))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/StakeTotalsViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@ariestools/sdk";
+import { XyoAddressZod as XyoAddressZod4 } from "@xyo-network/sdk";
+import { asAttoXL1 as asAttoXL15 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z12 } from "zod/mini";
+var StakeTotalsViewerRpcSchemas = {
+  stakeTotalsViewer_active: {
+    params: {
+      to: z12.optional(z12.tuple([z12.optional(z12.number())])),
+      from: z12.optional(z12.tuple([z12.optional(z12.number())]))
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_activeByStaked: {
+    params: {
+      to: z12.tuple([XyoAddressZod4, z12.optional(z12.number())]),
+      from: z12.tuple([XyoAddressZod4, z12.optional(z12.number())])
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_activeByStaker: {
+    params: {
+      to: z12.tuple([XyoAddressZod4, z12.optional(z12.number())]),
+      from: z12.tuple([XyoAddressZod4, z12.optional(z12.number())])
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_pending: {
+    params: {
+      to: z12.optional(z12.tuple([z12.optional(z12.number())])),
+      from: z12.optional(z12.tuple([z12.optional(z12.number())]))
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_pendingByStaker: {
+    params: {
+      to: z12.tuple([XyoAddressZod4, z12.optional(z12.number())]),
+      from: z12.tuple([XyoAddressZod4, z12.optional(z12.number())])
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_withdrawn: {
+    params: {
+      to: z12.optional(z12.tuple([z12.optional(z12.number())])),
+      from: z12.optional(z12.tuple([z12.optional(z12.number())]))
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  },
+  stakeTotalsViewer_withdrawnByStaker: {
+    params: {
+      to: z12.tuple([XyoAddressZod4, z12.optional(z12.number())]),
+      from: z12.tuple([XyoAddressZod4, z12.optional(z12.number())])
+    },
+    result: {
+      to: BigIntToJsonZod7,
+      from: z12.pipe(JsonToBigIntZod7, z12.transform((val) => asAttoXL15(val)))
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/StakeViewerRpcSchemas.ts
+import { XyoAddressZod as XyoAddressZod5 } from "@xyo-network/sdk";
+import { JsonToStakeZod, StakeToJsonZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z14 } from "zod";
+
+// src/modules/rpc/types/schema/NoArgsZod.ts
+import { z as z13 } from "zod";
+var NoArgsZod = z13.tuple([]).default([]);
+
+// src/modules/rpc/types/schema/StakeViewerRpcSchemas.ts
+var StakeViewerRpcSchemas = {
+  stakeViewer_minWithdrawalBlocks: {
+    params: {
+      to: NoArgsZod,
+      from: NoArgsZod
+    },
+    result: {
+      to: z14.number(),
+      from: z14.number()
+    }
+  },
+  stakeViewer_rewardsContract: {
+    params: {
+      to: NoArgsZod,
+      from: NoArgsZod
+    },
+    result: {
+      to: XyoAddressZod5,
+      from: XyoAddressZod5
+    }
+  },
+  stakeViewer_stakeById: {
+    params: {
+      to: z14.tuple([z14.number()]),
+      from: z14.tuple([z14.number()])
+    },
+    result: {
+      to: StakeToJsonZod,
+      from: JsonToStakeZod
+    }
+  },
+  stakeViewer_stakeByStaker: {
+    params: {
+      to: z14.tuple([XyoAddressZod5, z14.number()]),
+      from: z14.tuple([XyoAddressZod5, z14.number()])
+    },
+    result: {
+      to: StakeToJsonZod,
+      from: JsonToStakeZod
+    }
+  },
+  stakeViewer_stakesByStaker: {
+    params: {
+      to: z14.tuple([XyoAddressZod5]),
+      from: z14.tuple([XyoAddressZod5])
+    },
+    result: {
+      to: z14.array(StakeToJsonZod),
+      from: z14.array(JsonToStakeZod)
+    }
+  },
+  stakeViewer_stakesByStaked: {
+    params: {
+      to: z14.tuple([XyoAddressZod5]),
+      from: z14.tuple([XyoAddressZod5])
+    },
+    result: {
+      to: z14.array(StakeToJsonZod),
+      from: z14.array(JsonToStakeZod)
+    }
+  },
+  stakeViewer_stakingTokenAddress: {
+    params: {
+      to: NoArgsZod,
+      from: NoArgsZod
+    },
+    result: {
+      to: XyoAddressZod5,
+      from: XyoAddressZod5
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/StepRewardsViewerRpcSchemas.ts
+var NetworkStakingStepRewardsViewerRpcSchemas = {};
+
+// src/modules/rpc/types/schema/StepViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod8, JsonToBigIntZod as JsonToBigIntZod8 } from "@ariestools/sdk";
+import {
+  JsonToStakeZod as JsonToStakeZod2,
+  StakeToJsonZod as StakeToJsonZod2,
+  StepIdentityZod
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z15 } from "zod";
+var StepViewerRpcSchemas = {
+  randomizer: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: BigIntToJsonZod8,
+      from: JsonToBigIntZod8
+    }
+  },
+  stake: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: BigIntToJsonZod8,
+      from: JsonToBigIntZod8
+    }
+  },
+  stakers: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: BigIntToJsonZod8,
+      from: JsonToBigIntZod8
+    }
+  },
+  weight: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: BigIntToJsonZod8,
+      from: JsonToBigIntZod8
+    }
+  },
+  positionCount: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: z15.number(),
+      from: z15.number()
+    }
+  },
+  positions: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: z15.array(StakeToJsonZod2),
+      from: z15.array(JsonToStakeZod2)
+    }
+  },
+  stakerCount: {
+    params: {
+      to: z15.tuple([StepIdentityZod]),
+      from: z15.tuple([StepIdentityZod])
+    },
+    result: {
+      to: z15.number(),
+      from: z15.number()
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/TimeSyncViewerRpcSchema.ts
+import { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z16 } from "zod";
+var TimeSyncViewerRpcSchemas = {
+  timeSyncViewer_convertTime: {
+    params: {
+      from: z16.tuple([TimeDomainZod, TimeDomainZod, z16.number()]),
+      to: z16.tuple([TimeDomainZod, TimeDomainZod, z16.number()])
+    },
+    result: {
+      from: z16.number(),
+      to: z16.number()
+    }
+  },
+  timeSyncViewer_currentTime: {
+    params: {
+      from: z16.tuple([TimeDomainZod]),
+      to: z16.tuple([TimeDomainZod])
+    },
+    result: {
+      from: z16.tuple([TimeDomainZod, z16.number()]),
+      to: z16.tuple([TimeDomainZod, z16.number()])
+    }
+  },
+  timeSyncViewer_currentTimeAndHash: {
+    params: {
+      from: z16.tuple([TimeDomainZod]),
+      to: z16.tuple([TimeDomainZod])
+    },
+    result: {
+      from: z16.tuple([z16.number(), z16.nullable(z16.string())]),
+      to: z16.tuple([z16.number(), z16.nullable(z16.string())])
+    }
+  },
+  timeSyncViewer_currentTimePayload: {
+    params: {
+      from: z16.tuple([]).default([]),
+      to: z16.tuple([]).default([])
+    },
+    result: {
+      from: TimePayloadZod,
+      to: TimePayloadZod
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/TransactionViewerRpcSchema.ts
+import { HashZod as HashZod4 } from "@ariestools/sdk";
+import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z17 } from "zod/mini";
+var TransactionViewerRpcSchemas = {
+  transactionViewer_byHash: {
+    params: {
+      to: z17.tuple([HashZod4]),
+      from: z17.tuple([HashZod4])
+    },
+    result: {
+      to: z17.nullable(SignedHydratedTransactionWithHashMetaZod2),
+      from: z17.nullable(SignedHydratedTransactionWithHashMetaZod2)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/XyoPermissionsRpcSchemas.ts
+import {
+  InvokerPermissionZod,
+  PermissionRequestZod,
+  RequestedPermissionZod
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z18 } from "zod";
+var XyoPermissionsRpcSchemas = {
+  xyoPermissions_getPermissions: {
+    params: {
+      to: z18.tuple([]).default([]),
+      from: z18.tuple([]).default([])
+    },
+    result: {
+      to: z18.array(InvokerPermissionZod),
+      from: z18.array(InvokerPermissionZod)
+    }
+  },
+  xyoPermissions_requestPermissions: {
+    params: {
+      to: z18.tuple([z18.array(PermissionRequestZod)]),
+      from: z18.tuple([z18.array(PermissionRequestZod)])
+    },
+    result: {
+      to: z18.array(RequestedPermissionZod),
+      from: z18.array(RequestedPermissionZod)
+    }
+  },
+  xyoPermissions_revokePermissions: {
+    params: {
+      to: z18.tuple([z18.array(PermissionRequestZod)]),
+      from: z18.tuple([z18.array(PermissionRequestZod)])
+    },
+    result: {
+      to: z18.array(RequestedPermissionZod),
+      from: z18.array(RequestedPermissionZod)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/XyoRunnerRpcSchemas.ts
+import { HashToJsonZod, JsonToHashZod } from "@ariestools/sdk";
+import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z19 } from "zod";
+var XyoRunnerRpcSchemas = {
+  xyoRunner_broadcastTransaction: {
+    params: {
+      to: z19.tuple([SignedHydratedTransactionZod2]),
+      from: z19.tuple([SignedHydratedTransactionZod2])
+    },
+    result: {
+      to: HashToJsonZod,
+      from: JsonToHashZod
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/XyoSignerRpcSchemas.ts
+import {
+  AnyUnsignedBoundWitnessZod,
+  PayloadZodLoose as PayloadZodLoose2,
+  SignedBoundWitnessZod,
+  WithHashMetaPayloadZodLoose as WithHashMetaPayloadZodLoose2,
+  WithHashMetaZod,
+  XyoAddressZod as XyoAddressZod6
+} from "@xyo-network/sdk";
+import { z as z20 } from "zod/mini";
+var UnsignedHydratedBoundWitnessLooseZod = z20.tuple([
+  AnyUnsignedBoundWitnessZod,
+  z20.array(PayloadZodLoose2)
+]);
+var WithHashMetaSignedBoundWitnessZod = WithHashMetaZod(SignedBoundWitnessZod);
+var WithHashMetaSignedBoundWitnessZodLoose = z20.looseObject(WithHashMetaSignedBoundWitnessZod.shape);
+var SignedHydratedBoundWitnessWithHashMetaLooseZod = z20.tuple([
+  WithHashMetaSignedBoundWitnessZodLoose,
+  z20.array(WithHashMetaPayloadZodLoose2)
+]);
+var XyoSignerRpcSchemas = {
+  xyoSigner_address: {
+    params: {
+      to: NoArgsZod,
+      from: NoArgsZod
+    },
+    result: {
+      to: XyoAddressZod6,
+      from: XyoAddressZod6
+    }
+  },
+  xyoSigner_sign: {
+    params: {
+      to: z20.tuple([UnsignedHydratedBoundWitnessLooseZod]),
+      from: z20.tuple([UnsignedHydratedBoundWitnessLooseZod])
+    },
+    result: {
+      to: SignedHydratedBoundWitnessWithHashMetaLooseZod,
+      from: SignedHydratedBoundWitnessWithHashMetaLooseZod
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/XyoViewerRpcSchemas.ts
+import {
+  BigIntToJsonZod as BigIntToJsonZod9,
+  HashZod as HashZod5,
+  HexZod,
+  JsonToBigIntZod as JsonToBigIntZod9
+} from "@ariestools/sdk";
+import { PayloadZodLoose as PayloadZodLoose3, XyoAddressZod as XyoAddressZod7 } from "@xyo-network/sdk";
+import {
+  asAttoXL1 as asAttoXL16,
+  JsonToStakeZod as JsonToStakeZod3,
+  SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod4,
+  SignedHydratedTransactionZod as SignedHydratedTransactionZod3,
+  StakeToJsonZod as StakeToJsonZod3,
+  StepIdentityZod as StepIdentityZod2,
+  XL1BlockNumberZod as XL1BlockNumberZod2
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { z as z21 } from "zod/mini";
+var XyoViewerRpcSchemas = {
+  xyoViewer_networkStakeStepRewardClaimedByAddress: {
+    params: {
+      to: z21.tuple([XyoAddressZod7]),
+      from: z21.tuple([XyoAddressZod7])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressReward: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, XyoAddressZod7]),
+      from: z21.tuple([StepIdentityZod2, XyoAddressZod7])
+    },
+    result: {
+      to: z21.record(XyoAddressZod7, BigIntToJsonZod9),
+      from: z21.record(XyoAddressZod7, z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))))
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressHistory: {
+    params: {
+      to: z21.tuple([XyoAddressZod7]),
+      from: z21.tuple([XyoAddressZod7])
+    },
+    result: {
+      to: z21.record(XyoAddressZod7, BigIntToJsonZod9),
+      from: z21.record(XyoAddressZod7, z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))))
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressShare: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, XyoAddressZod7]),
+      from: z21.tuple([StepIdentityZod2, XyoAddressZod7])
+    },
+    result: {
+      to: z21.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z21.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
+    }
+  },
+  xyoViewer_networkStakeStepRewardWeightForAddress: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, XyoAddressZod7]),
+      from: z21.tuple([StepIdentityZod2, XyoAddressZod7])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
+    }
+  },
+  xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
+    params: {
+      to: z21.tuple([XyoAddressZod7]),
+      from: z21.tuple([XyoAddressZod7])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardPoolRewards: {
+    params: {
+      to: z21.tuple([StepIdentityZod2]),
+      from: z21.tuple([StepIdentityZod2])
+    },
+    result: {
+      to: z21.record(XyoAddressZod7, BigIntToJsonZod9),
+      from: z21.record(XyoAddressZod7, z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))))
+    }
+  },
+  xyoViewer_networkStakeStepRewardPositionWeight: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, z21.number()]),
+      from: z21.tuple([StepIdentityZod2, z21.number()])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
+    }
+  },
+  xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, z21.number()]),
+      from: z21.tuple([StepIdentityZod2, z21.number()])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardForStep: {
+    params: {
+      to: z21.tuple([StepIdentityZod2]),
+      from: z21.tuple([StepIdentityZod2])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardRandomizer: {
+    params: {
+      to: z21.tuple([StepIdentityZod2]),
+      from: z21.tuple([StepIdentityZod2])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardStakerCount: {
+    params: {
+      to: z21.tuple([StepIdentityZod2]),
+      from: z21.tuple([StepIdentityZod2])
+    },
+    result: {
+      to: z21.number(),
+      from: z21.number()
+    }
+  },
+  xyoViewer_networkStakeStepRewardPoolShares: {
+    params: {
+      to: z21.tuple([StepIdentityZod2]),
+      from: z21.tuple([StepIdentityZod2])
+    },
+    result: {
+      to: z21.record(XyoAddressZod7, BigIntToJsonZod9),
+      from: z21.record(XyoAddressZod7, JsonToBigIntZod9)
+    }
+  },
+  xyoViewer_networkStakeStepRewardForStepForPosition: {
+    params: {
+      to: z21.tuple([StepIdentityZod2, z21.number()]),
+      from: z21.tuple([StepIdentityZod2, z21.number()])
+    },
+    result: {
+      to: z21.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z21.tuple([z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))), z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))])
+    }
+  },
+  xyoViewer_networkStakeStepRewardForPosition: {
+    params: {
+      to: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])]),
+      from: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])])
+    },
+    result: {
+      to: z21.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z21.tuple([z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))), z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))])
+    }
+  },
+  xyoViewer_networkStakeStepRewardsForRange: {
+    params: {
+      to: z21.tuple([z21.tuple([z21.number(), z21.number()])]),
+      from: z21.tuple([z21.tuple([z21.number(), z21.number()])])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardsForStepLevel: {
+    params: {
+      to: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])]),
+      from: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))
+    }
+  },
+  xyoViewer_networkStakeStepRewardsForPosition: {
+    params: {
+      to: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])]),
+      from: z21.tuple([z21.number(), z21.tuple([z21.number(), z21.number()])])
+    },
+    result: {
+      to: z21.record(z21.string(), z21.tuple([BigIntToJsonZod9, BigIntToJsonZod9])),
+      from: z21.record(z21.string(), z21.tuple([z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val))), z21.pipe(JsonToBigIntZod9, z21.transform((val) => asAttoXL16(val)))]))
+    }
+  },
+  xyoViewer_blocksByNumber: {
+    params: {
+      to: z21.tuple([XL1BlockNumberZod2, z21.optional(z21.number())]),
+      from: z21.tuple([XL1BlockNumberZod2, z21.optional(z21.number())])
+    },
+    result: {
+      to: z21.array(SignedHydratedBlockWithHashMetaZod4),
+      from: z21.array(SignedHydratedBlockWithHashMetaZod4)
+    }
+  },
+  xyoViewer_blocksByHash: {
+    params: {
+      to: z21.tuple([HashZod5, z21.optional(z21.number())]),
+      from: z21.tuple([HashZod5, z21.optional(z21.number())])
+    },
+    result: {
+      to: z21.array(SignedHydratedBlockWithHashMetaZod4),
+      from: z21.array(SignedHydratedBlockWithHashMetaZod4)
+    }
+  },
+  xyoViewer_blocksByStep: {
+    params: {
+      to: z21.tuple([z21.number(), z21.number()]),
+      from: z21.tuple([z21.number(), z21.number()])
+    },
+    result: {
+      to: z21.array(SignedHydratedBlockWithHashMetaZod4),
+      from: z21.array(SignedHydratedBlockWithHashMetaZod4)
+    }
+  },
+  xyoViewer_currentBlock: {
+    params: {
+      to: z21._default(z21.tuple([]), []),
+      from: z21._default(z21.tuple([]), [])
+    },
+    result: {
+      to: SignedHydratedBlockWithHashMetaZod4,
+      from: SignedHydratedBlockWithHashMetaZod4
+    }
+  },
+  xyoViewer_forkHistory: {
+    params: {
+      to: z21._default(z21.tuple([]), []),
+      from: z21._default(z21.tuple([]), [])
+    },
+    result: {
+      to: z21.record(z21.number(), HexZod),
+      from: z21.record(z21.number(), HexZod)
+    }
+  },
+  xyoViewer_stakeByStaker: {
+    params: {
+      to: z21.tuple([XyoAddressZod7, z21.number()]),
+      from: z21.tuple([XyoAddressZod7, z21.number()])
+    },
+    result: {
+      to: StakeToJsonZod3,
+      from: JsonToStakeZod3
+    }
+  },
+  xyoViewer_stakeById: {
+    params: {
+      to: z21.tuple([z21.number()]),
+      from: z21.tuple([z21.number()])
+    },
+    result: {
+      to: StakeToJsonZod3,
+      from: JsonToStakeZod3
+    }
+  },
+  xyoViewer_stakesByStaker: {
+    params: {
+      to: z21.tuple([XyoAddressZod7]),
+      from: z21.tuple([XyoAddressZod7])
+    },
+    result: {
+      to: z21.array(StakeToJsonZod3),
+      from: z21.array(JsonToStakeZod3)
+    }
+  },
+  xyoViewer_stakesByStaked: {
+    params: {
+      to: z21.tuple([XyoAddressZod7]),
+      from: z21.tuple([XyoAddressZod7])
+    },
+    result: {
+      to: z21.array(StakeToJsonZod3),
+      from: z21.array(JsonToStakeZod3)
+    }
+  },
+  xyoViewer_transactionByBlockHashAndIndex: {
+    params: {
+      to: z21.tuple([HashZod5, z21.number()]),
+      from: z21.tuple([HashZod5, z21.number()])
+    },
+    result: {
+      to: z21.nullable(SignedHydratedTransactionZod3),
+      from: z21.nullable(SignedHydratedTransactionZod3)
+    }
+  },
+  xyoViewer_transactionByBlockNumberAndIndex: {
+    params: {
+      to: z21.tuple([z21.number(), z21.number()]),
+      from: z21.tuple([z21.number(), z21.number()])
+    },
+    result: {
+      to: z21.nullable(SignedHydratedTransactionZod3),
+      from: z21.nullable(SignedHydratedTransactionZod3)
+    }
+  },
+  xyoViewer_transactionByHash: {
+    params: {
+      to: z21.tuple([HashZod5]),
+      from: z21.tuple([HashZod5])
+    },
+    result: {
+      to: z21.nullable(SignedHydratedTransactionZod3),
+      from: z21.nullable(SignedHydratedTransactionZod3)
+    }
+  },
+  xyoViewer_payloadsByHash: {
+    params: {
+      to: z21.tuple([z21.array(HashZod5)]),
+      from: z21.tuple([z21.array(HashZod5)])
+    },
+    result: {
+      to: z21.array(PayloadZodLoose3),
+      from: z21.array(PayloadZodLoose3)
+    }
+  }
+};
+
+// src/modules/rpc/types/schema/AllRpcSchemas.ts
+var AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
+  ...XyoRunnerRpcSchemas,
+  ...XyoSignerRpcSchemas,
+  ...XyoViewerRpcSchemas,
+  ...XyoPermissionsRpcSchemas,
+  ...NetworkStakeViewerRpcSchemas,
+  ...BlockViewerRpcSchemas,
+  ...MempoolViewerRpcSchemas,
+  ...MempoolRunnerRpcSchemas,
+  ...TimeSyncViewerRpcSchemas,
+  ...StepViewerRpcSchemas,
+  ...DataLakeViewerRpcSchemas,
+  ...StakeTotalsViewerRpcSchemas,
+  ...StakeViewerRpcSchemas,
+  ...NetworkStakingStepRewardsViewerRpcSchemas,
+  ...NetworkStakingStepRewardsTotalViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByStepViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByStakerViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+  ...TransactionViewerRpcSchemas,
+  ...FinalizationViewerRpcSchemas
+};
+
+// src/modules/rpc/types/schema/createRequestSchema.ts
+import { z as z22 } from "zod/mini";
+var createRequestSchema = (methodName, paramsSchema = z22.undefined()) => z22.object({
+  id: z22.union([z22.string(), z22.number()]),
+  jsonrpc: z22.literal(jsonrpc),
+  method: z22.literal(methodName),
+  params: paramsSchema
+});
+
+// src/modules/rpc/types/schema/createResponseSchema.ts
+import { z as z23 } from "zod/mini";
+var createResponseSchema = (resultSchema = z23.undefined()) => z23.object({
+  id: z23.union([z23.string(), z23.number()]),
+  jsonrpc: z23.literal(jsonrpc),
+  result: resultSchema
+});
+
+// src/modules/rpc/types/schema/DataLakePageRpcSchemas.ts
+import { HashZod as HashZod6 } from "@ariestools/sdk";
+import { PayloadZodLoose as PayloadZodLoose4 } from "@xyo-network/sdk";
+import { ArrayBufferToJsonZod as ArrayBufferToJsonZod2, JsonToArrayBufferZod as JsonToArrayBufferWideZod } from "@xyo-network/xl1-protocol/protocol-model";
+import { z as z24 } from "zod";
+var JsonToArrayBufferZod2 = JsonToArrayBufferWideZod.pipe(z24.instanceof(ArrayBuffer));
+var DataLakePageRpcSchemas = {
+  xyoDataLakes_get: {
+    params: {
+      to: z24.tuple([z24.object({ id: z24.string(), hashes: z24.array(HashZod6) })]),
+      from: z24.tuple([z24.object({ id: z24.string(), hashes: z24.array(HashZod6) })])
+    },
+    result: {
+      to: z24.array(z24.union([PayloadZodLoose4, ArrayBufferToJsonZod2])),
+      from: z24.array(z24.union([PayloadZodLoose4, JsonToArrayBufferZod2]))
+    }
+  },
+  xyoDataLakes_insert: {
+    params: {
+      to: z24.tuple([
+        z24.object({
+          id: z24.string(),
+          payloads: z24.array(z24.union([PayloadZodLoose4, ArrayBufferToJsonZod2]))
+        })
+      ]),
+      from: z24.tuple([
+        z24.object({
+          id: z24.string(),
+          payloads: z24.array(z24.union([PayloadZodLoose4, JsonToArrayBufferZod2]))
+        })
+      ])
+    },
+    result: {
+      to: z24.array(z24.union([PayloadZodLoose4, ArrayBufferToJsonZod2])),
+      from: z24.array(z24.union([PayloadZodLoose4, JsonToArrayBufferZod2]))
+    }
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+
+// src/modules/rpc/provider/JsonRpcProvider.ts
+import { isDefined as isDefined5 } from "@ariestools/sdk";
+import { AbstractCreatableProvider } from "#protocol-sdk";
+
+// src/modules/rpc/transport/HttpRpcTransport.ts
+import {
+  FetchClientError,
+  FetchJsonClient,
+  isDefined,
+  isError,
+  isUndefinedOrNull
+} from "@ariestools/sdk";
+import { v4 } from "uuid";
+import { z as z25 } from "zod/mini";
+var HttpRpcTransport = class {
+  _passThrough;
+  _rpcUrl;
+  _schemas;
+  constructor(rpcUrl, schemas, passThrough = false) {
+    this._rpcUrl = rpcUrl;
+    this._schemas = schemas;
+    this._passThrough = passThrough;
+  }
+  async sendRequest(method, params) {
+    return await this.callRpc(this._rpcUrl, this._schemas, method, params);
+  }
+  async callRpc(url, schemas, method, params) {
+    try {
+      const id = v4();
+      const body = {
+        jsonrpc,
+        id,
+        method
+      };
+      const schema = schemas[method];
+      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 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})`);
+      }
+      if (json.error) {
+        throw new Error(json.error.message);
+      }
+      const result = isDefined(schema) ? schemas[method].result.from.parse(json.result) : json.result;
+      return result;
+    } catch (ex) {
+      let message = isError(ex) ? ex.message : String(ex);
+      if (ex instanceof FetchClientError) {
+        message = `Http error occurred [${ex.response.status}]: ${ex.message}`;
+      }
+      throw new Error(`Error occurred while calling RPC method ${String(method)}: ${message}`, { cause: ex });
+    }
+  }
+};
+
+// src/modules/rpc/transport/MemoryRpcTransport.ts
+import {
+  assertEx,
+  isObject,
+  isString
+} from "@ariestools/sdk";
+import { JsonRpcServer } from "@metamask/json-rpc-engine/v2";
+import { v4 as v42 } from "uuid";
+var MemoryRpcTransport = class {
+  _rpcEngine;
+  _rpcServer;
+  _schemas;
+  requestSchemas = {};
+  responseSchemas = {};
+  constructor(rpcEngine, schemas) {
+    this._rpcEngine = rpcEngine;
+    this._rpcServer = new JsonRpcServer({ engine: rpcEngine });
+    this._schemas = schemas;
+  }
+  async sendRequest(method, params) {
+    const schema = this._schemas[method];
+    let requestSchema = this.requestSchemas[method];
+    if (!isObject(requestSchema)) {
+      const stringMethod = assertEx(isString(method) ? method : null, () => "Method must be a string");
+      requestSchema = createRequestSchema(stringMethod, schema.params.to);
+      this.requestSchemas[method] = requestSchema;
+    }
+    const req = {
+      jsonrpc,
+      id: v42(),
+      method
+    };
+    if (params !== void 0) {
+      req.params = params;
+    }
+    const request = requestSchema.parse(req);
+    const result = await this._rpcServer.handle(request);
+    let responseSchema = this.responseSchemas[method];
+    if (!isObject(responseSchema)) {
+      responseSchema = createResponseSchema(schema.result.from);
+      this.responseSchemas[method] = responseSchema;
+    }
+    return responseSchema.parse(result)?.result;
+  }
+};
+
+// src/modules/rpc/transport/PostMessage/bus/Abstract.ts
+import { isDefined as isDefined2 } from "@ariestools/sdk";
+var AbstractMessageBus = class {
+  connections = [];
+  name;
+  sessionId;
+  constructor(sessionId, name = "default") {
+    this.name = name;
+    this.sessionId = sessionId;
+    this.start();
+  }
+  addConnection(connection) {
+    this.connections.push(connection);
+  }
+  removeConnection(connection) {
+    this.connections = this.connections.filter((c) => c !== connection);
+  }
+  validateSessionId(sessionId) {
+    return isDefined2(this.sessionId) && sessionId === this.sessionId;
+  }
+};
+
+// src/modules/rpc/transport/PostMessage/bus/implementations/PostMessage.ts
+import { isDefined as isDefined3 } from "@ariestools/sdk";
+
+// src/modules/rpc/transport/PostMessage/bus/validators/hasSessionId.ts
+var hasSessionId = (message) => {
+  return typeof message === "object" && message !== null && "sessionId" in message && typeof message.sessionId === "string";
+};
+
+// src/modules/rpc/transport/PostMessage/bus/validators/isEventWithId.ts
+var isEventWithId = (event) => {
+  return typeof event === "object" && event !== null && "data" in event && typeof event.data === "object" && event.data !== null && "data" in event.data && typeof event.data.data === "object" && event.data.data !== null && "id" in event.data.data && typeof event.data.data.id === "string";
+};
+
+// src/modules/rpc/transport/PostMessage/bus/validators/isMessageWithId.ts
+var isMessageWithId = (message) => {
+  return typeof message === "object" && message !== null && "data" in message && typeof message.data === "object" && message.data !== null && "id" in message.data && typeof message.data.id === "string";
+};
+
+// src/modules/rpc/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) {
+    deliverPostMessage(message, origin ?? browserWindow().location?.origin ?? "*");
+  }
+  start() {
+    addEventListener("message", (event) => this.handleMessage(event));
+  }
+  stop() {
+    removeEventListener("message", this.handleMessage);
+    this.connections.length = 0;
+  }
+  handleMessage = (event) => {
+    if (event.origin !== browserWindow().location?.origin) return;
+    if (!this.validateSessionId(event.data?.sessionId)) return;
+    for (const connection of this.connections) {
+      const { id, listener } = connection;
+      if (isDefined3(id) && isEventWithId(event)) {
+        const eventWithId = event;
+        if (eventWithId.data.data.id === id) listener(event);
+      } else {
+        listener(event);
+      }
+    }
+  };
+};
+
+// src/modules/rpc/transport/PostMessage/PostMessageRpcTransport.ts
+import { isDefined as isDefined4 } from "@ariestools/sdk";
+import {
+  isJsonRpcFailure,
+  isJsonRpcResponse,
+  isJsonRpcSuccess
+} from "@metamask/utils";
+import { v4 as v43 } from "uuid";
+var PostMessageRpcTransport = class {
+  _destination;
+  _logger;
+  _schemas;
+  _sessionId;
+  constructor(defaultDestination, schemas, sessionId, logger) {
+    this._schemas = schemas;
+    this._destination = defaultDestination;
+    this._logger = logger;
+    this._sessionId = sessionId;
+  }
+  get destination() {
+    return this._destination;
+  }
+  get logger() {
+    return this._logger;
+  }
+  get schemas() {
+    return this._schemas;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async sendRequest(method, params) {
+    const id = v43();
+    return await this.callRpc(this.schemas, method, id, params);
+  }
+  async callRpc(schemas, method, id, params) {
+    this.logger?.debug(`PostMessageRpcTransport: callRpc method=${String(method)} id=${id}`);
+    const body = {
+      jsonrpc,
+      id,
+      method,
+      params: isDefined4(params) && isDefined4(schemas[method]) ? schemas[method].params.to.parse(params) : params
+    };
+    return await new Promise((resolve, reject) => {
+      const postMessageBus = new PostMessageBus(this.sessionId);
+      const postMessageConnection = {
+        listener: (event) => {
+          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
+      };
+      postMessageBus.addConnection(postMessageConnection);
+      const message = {
+        data: body,
+        destination: this.destination,
+        sessionId: this.sessionId ?? ""
+      };
+      postMessageBus.postMessage(message);
+    });
+  }
+};
+
+// src/modules/rpc/provider/JsonRpcProvider.ts
+function resolveRpcConnection(connections) {
+  const named = connections["default-rpc"];
+  if (isDefined5(named) && named.type === "rpc") {
+    return named;
+  }
+  const first = Object.values(connections).find((connection) => connection?.type === "rpc");
+  return first;
+}
+var AbstractJsonRpcProvider = class extends AbstractCreatableProvider {
+  get transport() {
+    return this.params.transport;
+  }
+  async createHandler() {
+    this.params.transport ??= this.createTransport();
+    await super.createHandler();
+  }
+  createTransport() {
+    if (isDefined5(this.params.transport)) {
+      return this.params.transport;
+    }
+    if (isDefined5(this.params.rpcUrl)) {
+      return new HttpRpcTransport(this.params.rpcUrl, this.schemas());
+    }
+    const connection = resolveRpcConnection(this.config.connections);
+    if (isDefined5(connection)) {
+      if (connection.protocol === "postMessage" || isDefined5(connection.networkId)) {
+        return new PostMessageRpcTransport(connection.networkId ?? "", this.schemas(), connection.sessionId ?? "", this.logger);
+      }
+      if (isDefined5(connection.url)) {
+        return new HttpRpcTransport(connection.url, this.schemas());
+      }
+    }
+    throw new Error("Unable to create transport");
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcViewer.ts
+var AbstractJsonRpcViewer = class extends AbstractJsonRpcProvider {
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+var JsonRpcAccountBalanceViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = AccountBalanceViewerMoniker;
+  async qualifiedAccountBalanceHistories(addresses, config) {
+    return await this.transport.sendRequest(
+      "accountBalanceViewer_qualifiedAccountBalanceHistories",
+      [addresses, config]
+    );
+  }
+  async qualifiedAccountBalances(addresses, config) {
+    return await this.transport.sendRequest(
+      "accountBalanceViewer_qualifiedAccountBalances",
+      [addresses, config]
+    );
+  }
+  schemas() {
+    return AccountBalanceViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+var JsonRpcAccountBalanceViewer = class extends JsonRpcAccountBalanceViewerMethods {
+  async accountBalance(address, config = {}) {
+    const result = await this.accountBalances([address], config);
+    return result[address];
+  }
+  async accountBalanceHistories(address, config = {}) {
+    const [result] = await this.qualifiedAccountBalanceHistories(address, config);
+    return result;
+  }
+  async accountBalanceHistory(address, config = {}) {
+    const result = await this.accountBalanceHistories([address], config);
+    return result[address];
+  }
+  async accountBalances(address, config = {}) {
+    const [result] = await this.qualifiedAccountBalances(address, config);
+    return result;
+  }
+};
+__publicField(JsonRpcAccountBalanceViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcAccountBalanceViewer, "defaultMoniker", AccountBalanceViewerMoniker2);
+__publicField(JsonRpcAccountBalanceViewer, "dependencies", []);
+__publicField(JsonRpcAccountBalanceViewer, "monikers", [AccountBalanceViewerMoniker2]);
+__publicField(JsonRpcAccountBalanceViewer, "surface", "node");
+JsonRpcAccountBalanceViewer = __decorateClass([
+  creatableProvider()
+], JsonRpcAccountBalanceViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
+import { assertEx as assertEx2 } from "@ariestools/sdk";
+import { BlockViewerMoniker as BlockViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import {
+  calculateBlockRate,
+  calculateStepSizeRate,
+  calculateTimeRate,
+  creatableProvider as creatableProvider2
+} from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
+import { isDefined as isDefined6 } from "@ariestools/sdk";
+import { BlockViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = BlockViewerMoniker;
+  async blocksByHash(hash, limit) {
+    return await this.transport.sendRequest(
+      "blockViewer_blocksByHash",
+      isDefined6(limit) ? [hash, limit] : [hash]
+    );
+  }
+  async blocksByNumber(block, limit) {
+    return await this.transport.sendRequest(
+      "blockViewer_blocksByNumber",
+      isDefined6(limit) ? [block, limit] : [block]
+    );
+  }
+  async blocksByStep(stepLevel, stepIndex) {
+    return await this.transport.sendRequest(
+      "blockViewer_blocksByStep",
+      [stepLevel, stepIndex]
+    );
+  }
+  async currentBlock() {
+    return await this.transport.sendRequest(
+      "blockViewer_currentBlock",
+      []
+    );
+  }
+  async payloadsByHash(hashes) {
+    return await this.transport.sendRequest(
+      "blockViewer_payloadsByHash",
+      [hashes]
+    );
+  }
+  schemas() {
+    return BlockViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
+var MIN_HEAD_POLL_INTERVAL_MS = 5e3;
+var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
+  _headPollHash;
+  _headPollInProgress = false;
+  _headPollTimer = null;
+  get headPollIntervalMs() {
+    return this.params.headPollIntervalMs;
+  }
+  static async paramsHandler(params = {}) {
+    const headPollIntervalMs = params.headPollIntervalMs;
+    if (headPollIntervalMs !== void 0) {
+      assertEx2(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+    }
+    return {
+      ...await super.paramsHandler(params),
+      headPollIntervalMs
+    };
+  }
+  async blockByHash(hash) {
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
+  }
+  async blockByNumber(block) {
+    const blocks = await this.blocksByNumber(block, 1);
+    return blocks[0];
+  }
+  async chainId(blockNumber = "latest") {
+    if (blockNumber === "latest") {
+      const current = await this.currentBlock();
+      return current[0].chain;
+    }
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0][0].chain;
+  }
+  async currentBlockHash() {
+    const block = await this.currentBlock();
+    return block[0]._hash;
+  }
+  async currentBlockNumber() {
+    const block = await this.currentBlock();
+    return block[0].block;
+  }
+  async payloadByHash(hash) {
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
+  }
+  async rate(range, timeUnit) {
+    return await calculateBlockRate(this, range, timeUnit);
+  }
+  async stepSizeRate(start, stepSizeIndex, count, timeUnit) {
+    return await calculateStepSizeRate(this, start, stepSizeIndex, count, timeUnit);
+  }
+  async timeDurationRate(timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts) {
+    return await calculateTimeRate(this, timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts);
+  }
+  async startHandler() {
+    await super.startHandler();
+    if (this.headPollIntervalMs === void 0) return;
+    await this.pollHead(false);
+    this.startHeadPolling();
+  }
+  async stopHandler() {
+    this.stopHeadPolling();
+    this._headPollHash = void 0;
+    await super.stopHandler();
+  }
+  async pollHead(emitOnChange) {
+    if (this._headPollInProgress) return;
+    this._headPollInProgress = true;
+    try {
+      const block = await this.currentBlock();
+      const hash = block[0]._hash;
+      if (this._headPollHash === void 0) {
+        this._headPollHash = hash;
+        return;
+      }
+      if (hash !== this._headPollHash) {
+        this._headPollHash = hash;
+        if (emitOnChange) {
+          await this.emit("headUpdated", { block });
+        }
+      }
+    } catch (ex) {
+      this.logger?.error("Error polling block head", ex);
+    } finally {
+      this._headPollInProgress = false;
+    }
+  }
+  startHeadPolling() {
+    if (this.headPollIntervalMs === void 0) return;
+    this.stopHeadPolling();
+    this._headPollTimer = setInterval(() => {
+      void this.pollHead(true);
+    }, this.headPollIntervalMs);
+  }
+  stopHeadPolling() {
+    if (!this._headPollTimer) {
+      return;
+    }
+    clearInterval(this._headPollTimer);
+    this._headPollTimer = null;
+  }
+};
+__publicField(JsonRpcBlockViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcBlockViewer, "defaultMoniker", BlockViewerMoniker2);
+__publicField(JsonRpcBlockViewer, "dependencies", []);
+__publicField(JsonRpcBlockViewer, "monikers", [BlockViewerMoniker2]);
+__publicField(JsonRpcBlockViewer, "surface", "node");
+JsonRpcBlockViewer = __decorateClass([
+  creatableProvider2()
+], JsonRpcBlockViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
+import { FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider3 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewerMethods.ts
+import { FinalizationViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcFinalizationViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = FinalizationViewerMoniker;
+  async head() {
+    const result = await this.transport.sendRequest(
+      "finalizationViewer_head",
+      []
+    );
+    return result;
+  }
+  schemas() {
+    return FinalizationViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
+var JsonRpcFinalizationViewer = class extends JsonRpcFinalizationViewerMethods {
+  async chainId() {
+    const headBlock = await this.headBlock();
+    return headBlock.chain;
+  }
+  async headBlock() {
+    const head = await this.head();
+    return head[0];
+  }
+  async headHash() {
+    const head = await this.head();
+    return head[0]._hash;
+  }
+  async headNumber() {
+    const head = await this.head();
+    return head[0].block;
+  }
+};
+__publicField(JsonRpcFinalizationViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker2);
+__publicField(JsonRpcFinalizationViewer, "dependencies", []);
+__publicField(JsonRpcFinalizationViewer, "monikers", [FinalizationViewerMoniker2]);
+__publicField(JsonRpcFinalizationViewer, "surface", "node");
+JsonRpcFinalizationViewer = __decorateClass([
+  creatableProvider3()
+], JsonRpcFinalizationViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
+import { MempoolViewerMoniker as MempoolViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider4 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts
+import { MempoolViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = MempoolViewerMoniker;
+  async pendingBlocks(options) {
+    const result = await this.transport.sendRequest(
+      "mempoolViewer_pendingBlocks",
+      options ? [options] : []
+    );
+    return result;
+  }
+  async pendingTransactions(options) {
+    const result = await this.transport.sendRequest(
+      "mempoolViewer_pendingTransactions",
+      options ? [options] : []
+    );
+    return result;
+  }
+  schemas() {
+    return MempoolViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
+var JsonRpcMempoolViewer = class extends JsonRpcMempoolViewerMethods {
+};
+__publicField(JsonRpcMempoolViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcMempoolViewer, "defaultMoniker", MempoolViewerMoniker2);
+__publicField(JsonRpcMempoolViewer, "dependencies", []);
+__publicField(JsonRpcMempoolViewer, "monikers", [MempoolViewerMoniker2]);
+__publicField(JsonRpcMempoolViewer, "surface", "node");
+JsonRpcMempoolViewer = __decorateClass([
+  creatableProvider4()
+], JsonRpcMempoolViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
+import {
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider5 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts
+import { NetworkStakeStepRewardsViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcNetworkStakeStepRewardsViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = NetworkStakeStepRewardsViewerMoniker;
+  schemas() {
+    return NetworkStakingStepRewardsViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
+var JsonRpcNetworkStakeStepRewardsViewer = class extends JsonRpcNetworkStakeStepRewardsViewerMethods {
+  get position() {
+    return this.params.position;
+  }
+  get staker() {
+    return this.params.staker;
+  }
+  get step() {
+    return this.params.step;
+  }
+  get total() {
+    return this.params.total;
+  }
+};
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "dependencies", []);
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
+__publicField(JsonRpcNetworkStakeStepRewardsViewer, "surface", "node");
+JsonRpcNetworkStakeStepRewardsViewer = __decorateClass([
+  creatableProvider5()
+], JsonRpcNetworkStakeStepRewardsViewer);
+var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStakeStepRewardsViewer {
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
+import {
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
+  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider6 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
+import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcNetworkStakeViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = NetworkStakeViewerMoniker;
+  async active(blockNumber) {
+    return await this.transport.sendRequest("networkStakeViewer_active", [blockNumber]);
+  }
+  schemas() {
+    return NetworkStakeViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
+var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
+  _stepRewards;
+  get stepRewards() {
+    return this._stepRewards;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._stepRewards = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker3);
+  }
+};
+__publicField(JsonRpcNetworkStakeViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker2);
+__publicField(JsonRpcNetworkStakeViewer, "dependencies", []);
+__publicField(JsonRpcNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker2]);
+__publicField(JsonRpcNetworkStakeViewer, "surface", "node");
+JsonRpcNetworkStakeViewer = __decorateClass([
+  creatableProvider6()
+], JsonRpcNetworkStakeViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
+import { StakeTotalsViewerMoniker as StakeTotalsViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider7 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts
+import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcStakeTotalsViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = StakeTotalsViewerMoniker;
+  async active(time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_active", [time]);
+  }
+  async activeByStaked(staked, time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaked", [staked, time]);
+  }
+  async activeByStaker(address, time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaker", [address, time]);
+  }
+  async pending(time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_pending", [time]);
+  }
+  async pendingByStaker(staker, time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_pendingByStaker", [staker, time]);
+  }
+  async withdrawn(time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_withdrawn", [time]);
+  }
+  async withdrawnByStaker(staker, time) {
+    return await this.transport.sendRequest("stakeTotalsViewer_withdrawnByStaker", [staker, time]);
+  }
+  schemas() {
+    return StakeTotalsViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
+var JsonRpcStakeTotalsViewer = class extends JsonRpcStakeTotalsViewerMethods {
+};
+__publicField(JsonRpcStakeTotalsViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker2);
+__publicField(JsonRpcStakeTotalsViewer, "dependencies", []);
+__publicField(JsonRpcStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker2]);
+__publicField(JsonRpcStakeTotalsViewer, "surface", "node");
+JsonRpcStakeTotalsViewer = __decorateClass([
+  creatableProvider7()
+], JsonRpcStakeTotalsViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.ts
+import {
+  StakeEventsViewerMoniker,
+  StakeViewerMoniker as StakeViewerMoniker2
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider8 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.ts
+import { StakeViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcStakeViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = StakeViewerMoniker;
+  async minWithdrawalBlocks() {
+    return await this.transport.sendRequest("stakeViewer_minWithdrawalBlocks", []);
+  }
+  async rewardsContract() {
+    return await this.transport.sendRequest("stakeViewer_rewardsContract", []);
+  }
+  async stakeById(id) {
+    return await this.transport.sendRequest("stakeViewer_stakeById", [id]);
+  }
+  async stakeByStaker(staker, slot) {
+    return await this.transport.sendRequest("stakeViewer_stakeByStaker", [staker, slot]);
+  }
+  async stakesByStaked(staked) {
+    return await this.transport.sendRequest("stakeViewer_stakesByStaked", [staked]);
+  }
+  async stakesByStaker(staker) {
+    return await this.transport.sendRequest("stakeViewer_stakesByStaker", [staker]);
+  }
+  async stakingTokenAddress() {
+    return await this.transport.sendRequest("stakeViewer_stakingTokenAddress", []);
+  }
+  schemas() {
+    return StakeViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.ts
+var JsonRpcStakeViewer = class extends JsonRpcStakeViewerMethods {
+  _stakeEvents;
+  get stakeEvents() {
+    return this._stakeEvents;
+  }
+  activeStakes() {
+    return [];
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._stakeEvents = await this.locator.getInstance(StakeEventsViewerMoniker);
+  }
+  removedStakes() {
+    return [];
+  }
+  withdrawnStakes() {
+    return [];
+  }
+};
+__publicField(JsonRpcStakeViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcStakeViewer, "defaultMoniker", StakeViewerMoniker2);
+__publicField(JsonRpcStakeViewer, "dependencies", []);
+__publicField(JsonRpcStakeViewer, "monikers", [StakeViewerMoniker2]);
+__publicField(JsonRpcStakeViewer, "surface", "node");
+JsonRpcStakeViewer = __decorateClass([
+  creatableProvider8()
+], JsonRpcStakeViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
+import { TimeSyncViewerMoniker as TimeSyncViewerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider9 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
+import { TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcTimeSyncViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = TimeSyncViewerMoniker;
+  async convertTime(fromDomain, toDomain, from) {
+    return await this.transport.sendRequest("timeSyncViewer_convertTime", [fromDomain, toDomain, from]);
+  }
+  async currentTime(domain) {
+    return await this.transport.sendRequest("timeSyncViewer_currentTime", [domain]);
+  }
+  async currentTimeAndHash(domain) {
+    return await this.transport.sendRequest("timeSyncViewer_currentTimeAndHash", [domain]);
+  }
+  async currentTimePayload() {
+    return await this.transport.sendRequest("timeSyncViewer_currentTimePayload", []);
+  }
+  schemas() {
+    return TimeSyncViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
+var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
+};
+__publicField(JsonRpcTimeSyncViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcTimeSyncViewer, "defaultMoniker", TimeSyncViewerMoniker2);
+__publicField(JsonRpcTimeSyncViewer, "dependencies", []);
+__publicField(JsonRpcTimeSyncViewer, "monikers", [TimeSyncViewerMoniker2]);
+__publicField(JsonRpcTimeSyncViewer, "surface", "node");
+JsonRpcTimeSyncViewer = __decorateClass([
+  creatableProvider9()
+], JsonRpcTimeSyncViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcTransactionViewer/JsonRpcTransactionViewer.ts
+import {
+  assertEx as assertEx3,
+  exists
+} from "@ariestools/sdk";
+import { BoundWitnessSchema } from "@xyo-network/sdk";
+import {
+  BlockViewerMoniker as BlockViewerMoniker3,
+  isTransactionBoundWitnessWithHashMeta,
+  TransactionViewerMoniker
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider10 } from "#protocol-sdk";
+var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
+  moniker = JsonRpcTransactionViewer.defaultMoniker;
+  _blockViewer;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  async byBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.spanAsync("byBlockHashAndIndex", async () => {
+      assertEx3(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      try {
+        const block = await this.blockViewer.blockByHash(blockHash);
+        if (!block) return null;
+        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : void 0).filter(exists);
+        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map((index) => block[0].payload_hashes[index]));
+        const blockBoundWitnesses = block[1].filter((payload) => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash));
+        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithHashMeta);
+        const transaction = blockTransactionBoundWitnesses.at(transactionIndex);
+        if (!transaction) return null;
+        return await this.byHash(transaction._hash);
+      } catch {
+        return null;
+      }
+    }, this.context);
+  }
+  async byBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.spanAsync("transactionByBlockNumberAndIndex", async () => {
+      try {
+        const block = await this.blockViewer.blockByNumber(blockNumber);
+        if (!block) return null;
+        return await this.byBlockHashAndIndex(block[0]._hash, transactionIndex);
+      } catch {
+        return null;
+      }
+    }, this.context);
+  }
+  async byHash(transactionHash) {
+    const result = await this.transport.sendRequest("transactionViewer_byHash", [transactionHash]);
+    return result ?? null;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+  }
+  /** @deprecated Use {@link byBlockHashAndIndex} — this routes there. */
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.byBlockHashAndIndex(blockHash, transactionIndex);
+  }
+  /** @deprecated Use {@link byBlockNumberAndIndex} — this routes there. */
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.byBlockNumberAndIndex(blockNumber, transactionIndex);
+  }
+  /** @deprecated Use {@link byHash} — this routes there. */
+  async transactionByHash(transactionHash) {
+    return await this.byHash(transactionHash);
+  }
+  schemas() {
+    return TransactionViewerRpcSchemas;
+  }
+};
+__publicField(JsonRpcTransactionViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcTransactionViewer, "defaultMoniker", TransactionViewerMoniker);
+__publicField(JsonRpcTransactionViewer, "dependencies", [
+  BlockViewerMoniker3
+]);
+__publicField(JsonRpcTransactionViewer, "monikers", [TransactionViewerMoniker]);
+__publicField(JsonRpcTransactionViewer, "surface", "node");
+JsonRpcTransactionViewer = __decorateClass([
+  creatableProvider10()
+], JsonRpcTransactionViewer);
+
+// src/modules/rpc/provider/viewer/JsonRpcXyoViewer.ts
+import {
+  assertEx as assertEx4,
+  isUndefined
+} from "@ariestools/sdk";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
+  BlockViewerMoniker as BlockViewerMoniker4,
+  FinalizationViewerMoniker as FinalizationViewerMoniker3,
+  isSignedHydratedBlock,
+  isSignedHydratedBlockWithHashMeta,
+  MempoolViewerMoniker as MempoolViewerMoniker3,
+  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker3,
+  StakeViewerMoniker as StakeViewerMoniker3,
+  StepViewerMoniker,
+  TimeSyncViewerMoniker as TimeSyncViewerMoniker3,
+  TransactionViewerMoniker as TransactionViewerMoniker2,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider11 } from "#protocol-sdk";
+async function fixSignedHydratedBlockWithHashMeta(block) {
+  if (isSignedHydratedBlockWithHashMeta(block)) {
+    return block;
+  }
+  if (isSignedHydratedBlock(block)) {
+    return [await PayloadBuilder.addHashMeta(block[0]), await PayloadBuilder.addHashMeta(block[1])];
+  }
+  throw new Error("Invalid block format");
+}
+var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
+  moniker = JsonRpcXyoViewer.defaultMoniker;
+  _chainId;
+  _providers = void 0;
+  get account() {
+    return { balance: assertEx4(this.providers?.[AccountBalanceViewerMoniker3], () => `AccountBalanceViewer provider not found for ${this.moniker}`) };
+  }
+  get block() {
+    return assertEx4(this.providers?.[BlockViewerMoniker4], () => `BlockViewer provider not found for ${this.moniker}`);
+  }
+  get finalization() {
+    return assertEx4(this.providers?.[FinalizationViewerMoniker3], () => `FinalizationViewer provider not found for ${this.moniker}`);
+  }
+  get mempool() {
+    return assertEx4(this.providers?.[MempoolViewerMoniker3], () => `MempoolViewer provider not found for ${this.moniker}`);
+  }
+  get networkStake() {
+    return assertEx4(this.providers?.[NetworkStakeViewerMoniker3], () => `NetworkStakeViewer provider not found for ${this.moniker}`);
+  }
+  get stake() {
+    return assertEx4(this.providers?.[StakeViewerMoniker3], () => `StakeViewer provider not found for ${this.moniker}`);
+  }
+  get step() {
+    return assertEx4(this.providers?.[StepViewerMoniker], () => `StepViewer provider not found for ${this.moniker}`);
+  }
+  get time() {
+    return assertEx4(this.providers?.[TimeSyncViewerMoniker3], () => `TimeSyncViewer provider not found for ${this.moniker}`);
+  }
+  get transaction() {
+    return assertEx4(this.providers?.[TransactionViewerMoniker2], () => `TransactionViewer provider not found for ${this.moniker}`);
+  }
+  get providers() {
+    return this._providers;
+  }
+  async accountBalance(address, config = {}) {
+    return await this.account.balance.accountBalance(address, config);
+  }
+  async accountBalanceHistory(address, config = {}) {
+    return await this.account.balance.accountBalanceHistory(address, config);
+  }
+  async blockByHash(hash) {
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
+  }
+  async blockByNumber(blockNumber) {
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0];
+  }
+  async blocksByHash(hash, limit) {
+    const blocks = await this.transport.sendRequest(
+      "xyoViewer_blocksByHash",
+      [hash, limit]
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+  }
+  async blocksByNumber(blockNumber, limit) {
+    const blocks = await this.transport.sendRequest(
+      "xyoViewer_blocksByNumber",
+      [blockNumber, limit]
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+  }
+  async blocksByStep(stepLevel, stepIndex) {
+    const blocks = await this.transport.sendRequest(
+      "xyoViewer_blocksByStep",
+      [stepLevel, stepIndex]
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+  }
+  async chainId(blockNumber = "latest") {
+    const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
+    if (!block) {
+      throw new Error(`Block not found: ${blockNumber}`);
+    }
+    return block[0].chain;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._providers = {
+      [AccountBalanceViewerMoniker3]: await this.locator.getInstance(AccountBalanceViewerMoniker3),
+      [BlockViewerMoniker4]: await this.locator.getInstance(BlockViewerMoniker4),
+      [FinalizationViewerMoniker3]: await this.locator.getInstance(FinalizationViewerMoniker3),
+      [MempoolViewerMoniker3]: await this.locator.getInstance(MempoolViewerMoniker3),
+      [StakeViewerMoniker3]: await this.locator.getInstance(StakeViewerMoniker3),
+      [StepViewerMoniker]: await this.locator.getInstance(StepViewerMoniker),
+      [NetworkStakeViewerMoniker3]: await this.locator.getInstance(NetworkStakeViewerMoniker3),
+      [TimeSyncViewerMoniker3]: await this.locator.getInstance(TimeSyncViewerMoniker3),
+      [TransactionViewerMoniker2]: await this.locator.getInstance(TransactionViewerMoniker2)
+    };
+    for (const [moniker, provider] of Object.entries(assertEx4(this._providers, () => "Failed to initialize JsonRpcXyoViewer: providers not found"))) {
+      if (isUndefined(provider)) {
+        throw new Error(`Failed to initialize JsonRpcXyoViewer: missing provider dependency for ${moniker}`);
+      }
+    }
+  }
+  async currentBlock() {
+    const result = await this.transport.sendRequest("xyoViewer_currentBlock");
+    return fixSignedHydratedBlockWithHashMeta(result);
+  }
+  async currentBlockHash() {
+    const block = await this.currentBlock();
+    return block[0]._hash;
+  }
+  async currentBlockNumber() {
+    const block = await this.currentBlock();
+    return block[0].block;
+  }
+  async forkHistory() {
+    return await this.transport.sendRequest("xyoViewer_forkHistory");
+  }
+  async networkStakeStepRewardAddressHistory(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressHistory", [address]);
+  }
+  async networkStakeStepRewardAddressReward(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressReward", [context, address]);
+  }
+  async networkStakeStepRewardAddressShare(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressShare", [context, address]);
+  }
+  async networkStakeStepRewardClaimedByAddress(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardClaimedByAddress", [address]);
+  }
+  async networkStakeStepRewardForPosition(position, range) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForPosition", [position, range]);
+  }
+  async networkStakeStepRewardForStep(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStep", [context]);
+  }
+  async networkStakeStepRewardForStepForPosition(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStepForPosition", [context, position]);
+  }
+  async networkStakeStepRewardPoolRewards(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolRewards", [context]);
+  }
+  async networkStakeStepRewardPoolShares(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolShares", [context]);
+  }
+  async networkStakeStepRewardPositionWeight(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPositionWeight", [context, position]);
+  }
+  async networkStakeStepRewardPotentialPositionLoss(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPotentialPositionLoss", [context, position]);
+  }
+  async networkStakeStepRewardRandomizer(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardRandomizer", [context]);
+  }
+  async networkStakeStepRewardStakerCount(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardStakerCount", [context]);
+  }
+  async networkStakeStepRewardUnclaimedByAddress(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardUnclaimedByAddress", [address]);
+  }
+  async networkStakeStepRewardWeightForAddress(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardWeightForAddress", [context, address]);
+  }
+  async networkStakeStepRewardsForPosition(position, range) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForPosition", [position, range]);
+  }
+  async networkStakeStepRewardsForRange(range) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForRange", [range]);
+  }
+  async networkStakeStepRewardsForStepLevel(stepLevel, range) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForStepLevel", [stepLevel, range]);
+  }
+  async payloadByHash(hash) {
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
+  }
+  async payloadsByHash(hashes) {
+    return await PayloadBuilder.addHashMeta(await this.transport.sendRequest(
+      "xyoViewer_payloadsByHash",
+      [hashes]
+    ));
+  }
+  async rate(range, timeUnit) {
+    return await this.block.rate(range, timeUnit);
+  }
+  async stakeById(id) {
+    return await this.transport.sendRequest("xyoViewer_stakeById", [id]);
+  }
+  async stakeByStaker(staker, slot) {
+    return await this.transport.sendRequest("xyoViewer_stakeByStaker", [staker, slot]);
+  }
+  async stakesByStaked(staked) {
+    return await this.transport.sendRequest("xyoViewer_stakesByStaked", [staked]);
+  }
+  async stakesByStaker(staker) {
+    return await this.transport.sendRequest("xyoViewer_stakesByStaker", [staker]);
+  }
+  async stepSizeRate(start, stepIndex, count, timeUnit) {
+    return await this.block.stepSizeRate(start, stepIndex, count, timeUnit);
+  }
+  async timeDurationRate(timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts) {
+    return await this.block.timeDurationRate(timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts);
+  }
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
+  }
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
+  }
+  async transactionByHash(transactionHash) {
+    return await this.transport.sendRequest("xyoViewer_transactionByHash", [transactionHash]);
+  }
+  schemas() {
+    return XyoViewerRpcSchemas;
+  }
+};
+__publicField(JsonRpcXyoViewer, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcXyoViewer, "defaultMoniker", XyoViewerMoniker);
+__publicField(JsonRpcXyoViewer, "dependencies", [
+  AccountBalanceViewerMoniker3,
+  BlockViewerMoniker4,
+  FinalizationViewerMoniker3,
+  MempoolViewerMoniker3,
+  NetworkStakeViewerMoniker3,
+  StakeViewerMoniker3,
+  StepViewerMoniker,
+  TimeSyncViewerMoniker3,
+  TransactionViewerMoniker2
+]);
+__publicField(JsonRpcXyoViewer, "monikers", [XyoViewerMoniker]);
+__publicField(JsonRpcXyoViewer, "surface", "node");
+JsonRpcXyoViewer = __decorateClass([
+  creatableProvider11()
+], JsonRpcXyoViewer);
+
+// src/modules/rpc/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+var JsonRpcDataLakeViewerMethods = class _JsonRpcDataLakeViewerMethods extends AbstractJsonRpcViewer {
+  static defaultMoniker = DataLakeViewerMoniker;
+  static monikers = [DataLakeViewerMoniker];
+  moniker = _JsonRpcDataLakeViewerMethods.defaultMoniker;
+  get(_hashes) {
+    throw new Error("Method [get] not implemented.");
+  }
+  next(_options) {
+    throw new Error("Method [next] not implemented.");
+  }
+  schemas() {
+    return DataLakeViewerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/datalake/JsonRpcDataLakeViewer.ts
+var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
+};
+__publicField(JsonRpcDataLakeViewer, "dependencies", []);
+JsonRpcDataLakeViewer = __decorateClass([
+  creatableProvider12()
+], JsonRpcDataLakeViewer);
+
+// src/modules/rpc/provider/permissions/RpcXyoPermissions.ts
+var RpcXyoPermissions = class {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getPermissions() {
+    return await this.transport.sendRequest("xyoPermissions_getPermissions", []);
+  }
+  async requestPermissions(permissions) {
+    return await this.transport.sendRequest("xyoPermissions_requestPermissions", [permissions]);
+  }
+  async revokePermissions(_permissions) {
+    await Promise.resolve();
+    throw new Error("Method [revokePermissions] not implemented.");
+  }
+};
+
+// src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
+import { MempoolRunnerMoniker as MempoolRunnerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider13 } from "#protocol-sdk";
+
+// src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+import { elevatedTransaction, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+
+// src/modules/rpc/provider/runner/JsonRpcRunner.ts
+var AbstractJsonRpcRunner = class extends AbstractJsonRpcProvider {
+};
+
+// src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
+  moniker = MempoolRunnerMoniker;
+  async submitBlocks(blocks) {
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitBlocks",
+      [blocks]
+    );
+    return result;
+  }
+  async submitTransactions(transactions) {
+    const elevated = await Promise.all(
+      transactions.map(async ([bw, payloads]) => elevatedTransaction([
+        await PayloadBuilder2.addHashMeta(bw),
+        await PayloadBuilder2.addHashMeta(payloads)
+      ]))
+    );
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitTransactions",
+      [elevated]
+    );
+    return result;
+  }
+  schemas() {
+    return MempoolRunnerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
+var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
+  prunePendingBlocks(_options) {
+    throw new Error("Method not implemented.");
+  }
+  prunePendingTransactions(_options) {
+    throw new Error("Method not implemented.");
+  }
+};
+__publicField(JsonRpcMempoolRunner, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker2);
+__publicField(JsonRpcMempoolRunner, "dependencies", []);
+__publicField(JsonRpcMempoolRunner, "monikers", [MempoolRunnerMoniker2]);
+__publicField(JsonRpcMempoolRunner, "surface", "node");
+JsonRpcMempoolRunner = __decorateClass([
+  creatableProvider13()
+], JsonRpcMempoolRunner);
+
+// src/modules/rpc/provider/runner/JsonRpcXyoRunner.ts
+import { MempoolRunnerMoniker as MempoolRunnerMoniker3, XyoRunnerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+import { creatableProvider as creatableProvider14 } from "#protocol-sdk";
+var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
+  moniker = JsonRpcXyoRunner.defaultMoniker;
+  _mempoolRunner;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  async broadcastTransaction(transaction) {
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker3);
+  }
+  schemas() {
+    return XyoRunnerRpcSchemas;
+  }
+};
+__publicField(JsonRpcXyoRunner, "connectionTypes", ["rpc"]);
+__publicField(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
+__publicField(JsonRpcXyoRunner, "dependencies", [MempoolRunnerMoniker3]);
+__publicField(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
+__publicField(JsonRpcXyoRunner, "surface", "node");
+JsonRpcXyoRunner = __decorateClass([
+  creatableProvider14()
+], JsonRpcXyoRunner);
+
+// src/modules/rpc/provider/signer/JsonRpcXyoSigner.ts
+import { asSignedHydratedTransactionWithHashMeta, XyoSignerMoniker as XyoSignerMoniker2 } from "@xyo-network/xl1-protocol/protocol-lib";
+
+// src/modules/rpc/provider/signer/JsonRpcXyoSignerMethods.ts
+import { XyoSignerMoniker } from "@xyo-network/xl1-protocol/protocol-lib";
+var JsonRpcXyoSignerMethods = class extends AbstractJsonRpcRunner {
+  moniker = XyoSignerMoniker;
+  async address() {
+    return await this.transport.sendRequest("xyoSigner_address");
+  }
+  async sign(bw) {
+    return await this.transport.sendRequest("xyoSigner_sign", [bw]);
+  }
+  schemas() {
+    return XyoSignerRpcSchemas;
+  }
+};
+
+// src/modules/rpc/provider/signer/JsonRpcXyoSigner.ts
+var JsonRpcXyoSigner = class extends JsonRpcXyoSignerMethods {
+  static connectionTypes = ["rpc"];
+  static defaultMoniker = XyoSignerMoniker2;
+  static dependencies = [];
+  static monikers = [XyoSignerMoniker2];
+  static surface = "node";
+  async signTransaction(tx) {
+    return asSignedHydratedTransactionWithHashMeta(await this.sign(tx), true);
+  }
+};
+
+// src/modules/rpc/engine-node/composedRpcEngineFromConnection.ts
+import {
+  JsonRpcEngineV2,
+  JsonRpcServer as JsonRpcServer2
+} from "@metamask/json-rpc-engine/v2";
+
+// src/modules/rpc/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/modules/rpc/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/modules/rpc/engine-node/middleware/createMethodNotFoundMiddleware.ts
+var createMethodNotFoundMiddleware = () => ({ request }) => {
+  throw new Error(`${JsonRpcErrorCodes.MethodNotFound.message} (${request.method})`);
+};
+
+// src/modules/rpc/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/modules/rpc/engine-node/composedRpcEngineFromConnection.ts
+var buildTypedSubEngine = (schemas, handlers) => JsonRpcEngineV2.create({
+  middleware: [
+    createValidationMiddleware(schemas),
+    createTypedHandlerMiddleware(schemas, handlers)
+  ]
+});
+var composedRpcEngineFromConnection = (connection, logger) => {
+  const { runner, viewer } = connection;
+  const subEngines = [];
+  if (runner) {
+    subEngines.push(buildTypedSubEngine(XyoRunnerRpcSchemas, rpcMethodHandlersFromRunner(runner)));
+  }
+  if (viewer) {
+    subEngines.push(buildTypedSubEngine(XyoViewerRpcSchemas, rpcMethodHandlersFromViewer(viewer)));
+  }
+  const accountBalanceViewer = viewer?.account?.balance;
+  if (accountBalanceViewer) {
+    subEngines.push(buildTypedSubEngine(
+      AccountBalanceViewerRpcSchemas,
+      rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
+    ));
+  }
+  const blockViewer = viewer?.block;
+  if (blockViewer) {
+    subEngines.push(buildTypedSubEngine(
+      BlockViewerRpcSchemas,
+      rpcMethodHandlersFromBlockViewer(blockViewer)
+    ));
+  }
+  const finalizationViewer = viewer?.finalization;
+  if (finalizationViewer) {
+    subEngines.push(buildTypedSubEngine(
+      FinalizationViewerRpcSchemas,
+      rpcMethodHandlersFromFinalizationViewer(finalizationViewer)
+    ));
+  }
+  const mempoolViewer = viewer?.mempool;
+  if (mempoolViewer) {
+    subEngines.push(buildTypedSubEngine(
+      MempoolViewerRpcSchemas,
+      rpcMethodHandlersFromMempoolViewer(mempoolViewer)
+    ));
+  }
+  const timeSyncViewer = viewer?.time;
+  if (timeSyncViewer) {
+    subEngines.push(buildTypedSubEngine(
+      TimeSyncViewerRpcSchemas,
+      rpcMethodHandlersFromTimeSyncViewer(timeSyncViewer)
+    ));
+  }
+  const transactionViewer = viewer?.transaction;
+  if (transactionViewer) {
+    subEngines.push(buildTypedSubEngine(
+      TransactionViewerRpcSchemas,
+      rpcMethodHandlersFromTransactionViewer(transactionViewer)
+    ));
+  }
+  const mempoolRunner = runner?.mempool;
+  if (mempoolRunner) {
+    subEngines.push(buildTypedSubEngine(
+      MempoolRunnerRpcSchemas,
+      rpcMethodHandlersFromMempoolRunner(mempoolRunner)
+    ));
+  }
+  const networkStakeViewer = viewer?.networkStake;
+  if (networkStakeViewer?.stepRewards?.position) {
+    subEngines.push(buildTypedSubEngine(
+      NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+      rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
+    ));
+  }
+  const middleware = [
+    createLoggingMiddleware(logger),
+    ...subEngines.map((engine) => engine.asMiddleware()),
+    createMethodNotFoundMiddleware()
+  ];
+  return JsonRpcEngineV2.create({ middleware });
+};
+var composedRpcServerFromConnection = (connection, logger) => {
+  const engine = composedRpcEngineFromConnection(connection, logger);
+  return new JsonRpcServer2({ engine });
+};
+
+// src/modules/rpc/engine-node/createRpcDispatchMiddleware.ts
+var createRpcDispatchMiddleware = (schemas, handlers, options) => async ({ request }) => {
+  const method = request.method;
+  const handler = handlers[method];
+  const schema = schemas[method];
+  if (schema === void 0 || handler === void 0) {
+    const createError = options?.methodNotFound ?? (() => new Error(JsonRpcErrorCodes.MethodNotFound.message));
+    throw createError(method);
+  }
+  let requestSchema = requestSchemas[method];
+  if (requestSchema == void 0) {
+    requestSchema = createRequestSchema(method, schema.params.from);
+    requestSchemas[method] = requestSchema;
+  }
+  const parsed = requestSchema.safeParse(request);
+  if (!parsed.success) {
+    options?.logger?.error("RPC Request Validation Error", parsed.error);
+    throw new Error(parsed.error.message);
+  }
+  const { params } = parsed.data;
+  try {
+    const result = await handler(params);
+    return schema.result.to.parse(result);
+  } catch (error) {
+    options?.logger?.error("RPC Response Handler Error", error);
+    throw error;
+  }
+};
+
+// src/modules/rpc/engine-node/rpcEngineFromConnection.ts
+import { JsonRpcEngineV2 as JsonRpcEngineV22, JsonRpcServer as JsonRpcServer3 } from "@metamask/json-rpc-engine/v2";
+var rpcEngineFromConnection = (connection, logger) => {
+  const handlers = rpcMethodHandlersFromConnection(connection);
+  const middleware = createRpcDispatchMiddleware(AllRpcSchemas, handlers, { logger });
+  return JsonRpcEngineV22.create({ middleware: [middleware] });
+};
+function rpcServerFromConnection(connection, logger) {
+  const engine = rpcEngineFromConnection(connection, logger);
+  return new JsonRpcServer3({ engine });
+}
+export {
+  AbstractJsonRpcProvider,
+  AbstractJsonRpcRunner,
+  AbstractJsonRpcViewer,
+  AbstractMessageBus,
+  AccountBalanceViewerRpcSchemas,
+  AllRpcSchemas,
+  BlockViewerRpcSchemas,
+  DataLakePageRpcSchemas,
+  DataLakeViewerRpcSchemas,
+  DataLakesGetMethod,
+  DataLakesInsertMethod,
+  DataLakesPageMethodPrefix,
+  FinalizationViewerRpcSchemas,
+  HttpRpcTransport,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcAccountBalanceViewerMethods,
+  JsonRpcBlockViewer,
+  JsonRpcBlockViewerMethods,
+  JsonRpcDataLakeViewer,
+  JsonRpcDataLakeViewerMethods,
+  JsonRpcErrorCodes,
+  JsonRpcFinalizationViewer,
+  JsonRpcFinalizationViewerMethods,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolRunnerMethods,
+  JsonRpcMempoolViewer,
+  JsonRpcMempoolViewerMethods,
+  JsonRpcNetworkStakeStepRewardsViewer,
+  JsonRpcNetworkStakeStepRewardsViewerMethods,
+  JsonRpcNetworkStakeViewer,
+  JsonRpcNetworkStakeViewerMethods,
+  JsonRpcNetworkStakingStepRewardsViewer,
+  JsonRpcStakeTotalsViewer,
+  JsonRpcStakeTotalsViewerMethods,
+  JsonRpcStakeViewer,
+  JsonRpcStakeViewerMethods,
+  JsonRpcTimeSyncViewer,
+  JsonRpcTimeSyncViewerMethods,
+  JsonRpcTransactionViewer,
+  JsonRpcXyoRunner,
+  JsonRpcXyoSigner,
+  JsonRpcXyoSignerMethods,
+  JsonRpcXyoViewer,
+  MemoryRpcTransport,
+  MempoolRunnerRpcSchemas,
+  MempoolViewerRpcSchemas,
+  NetworkStakeViewerRpcNamespace,
+  NetworkStakeViewerRpcSchemas,
+  NetworkStakingStepRewardsByPositionViewerRpcNamespace,
+  NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+  NetworkStakingStepRewardsByStakerViewerRpcNamespace,
+  NetworkStakingStepRewardsByStakerViewerRpcSchemas,
+  NetworkStakingStepRewardsByStepViewerRpcNamespace,
+  NetworkStakingStepRewardsByStepViewerRpcSchemas,
+  NetworkStakingStepRewardsTotalViewerRpcNamespace,
+  NetworkStakingStepRewardsTotalViewerRpcSchemas,
+  NetworkStakingStepRewardsViewerRpcNamespace,
+  NetworkStakingStepRewardsViewerRpcSchemas,
+  NoArgsZod,
+  PostMessageBus,
+  PostMessageRpcTransport,
+  RpcXyoPermissions,
+  StakeTotalsViewerRpcSchemas,
+  StakeViewerRpcSchemas,
+  TimeSyncViewerRpcSchemas,
+  TransactionViewerRpcSchemas,
+  XyoPermissionsRpcSchemas,
+  XyoRunnerRpcSchemas,
+  XyoSignerRpcSchemas,
+  XyoViewerRpcSchemas,
+  composedRpcEngineFromConnection,
+  composedRpcServerFromConnection,
+  createLoggingMiddleware,
+  createMethodNotFoundMiddleware,
+  createRequestSchema,
+  createResponseSchema,
+  createRpcDispatchMiddleware,
+  createTypedHandlerMiddleware,
+  createValidationMiddleware,
+  hasSessionId,
+  isEventWithId,
+  isMessageWithId,
+  jsonrpc,
+  requestSchemas,
+  rpcEngineFromConnection,
+  rpcMethodHandlersFromAccountBalanceViewer,
+  rpcMethodHandlersFromBlockViewer,
+  rpcMethodHandlersFromConnection,
+  rpcMethodHandlersFromFinalizationViewer,
+  rpcMethodHandlersFromMempoolRunner,
+  rpcMethodHandlersFromMempoolViewer,
+  rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer,
+  rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer,
+  rpcMethodHandlersFromNetworkStakingViewer,
+  rpcMethodHandlersFromPermissions,
+  rpcMethodHandlersFromRunner,
+  rpcMethodHandlersFromSigner,
+  rpcMethodHandlersFromTimeSyncViewer,
+  rpcMethodHandlersFromTransactionViewer,
+  rpcMethodHandlersFromViewer,
+  rpcServerFromConnection
+};
+//# sourceMappingURL=rpc.mjs.map