@xyo-network/xl1-rpc 4.0.11 → 4.0.12

package/dist/neutral/index.mjs

@@ -1,3150 +1,3 @@
-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/engine/requestSchemas.ts
-var requestSchemas = {};
-
-// src/engine/rpcMethodHandlersFromAccountBalanceViewer.ts
-var rpcMethodHandlersFromAccountBalanceViewer = (viewer) => {
-  return {
-    accountBalanceViewer_qualifiedAccountBalances: (params) => viewer.qualifiedAccountBalances(...params ?? []),
-    accountBalanceViewer_qualifiedAccountBalanceHistories: (params) => viewer.qualifiedAccountBalanceHistories(...params ?? [])
-  };
-};
-
-// src/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/engine/rpcMethodHandlersFromFinalizationViewer.ts
-var rpcMethodHandlersFromFinalizationViewer = (viewer) => {
-  return { finalizationViewer_head: (params) => viewer.head(...params ?? []) };
-};
-
-// src/engine/rpcMethodHandlersFromMempoolRunner.ts
-var rpcMethodHandlersFromMempoolRunner = (runner) => {
-  return {
-    mempoolRunner_submitBlocks: (params) => runner.submitBlocks(...params ?? []),
-    mempoolRunner_submitTransactions: (params) => runner.submitTransactions(...params ?? [])
-  };
-};
-
-// src/engine/rpcMethodHandlersFromMempoolViewer.ts
-var rpcMethodHandlersFromMempoolViewer = (viewer) => {
-  return {
-    mempoolViewer_pendingBlocks: (params) => viewer.pendingBlocks(...params ?? []),
-    mempoolViewer_pendingTransactions: (params) => viewer.pendingTransactions(...params ?? [])
-  };
-};
-
-// src/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/engine/rpcMethodHandlersFromRunner.ts
-var rpcMethodHandlersFromRunner = (runner) => {
-  return { xyoRunner_broadcastTransaction: (params) => runner.broadcastTransaction(...params ?? []) };
-};
-
-// src/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/engine/rpcMethodHandlersFromTransactionViewer.ts
-var rpcMethodHandlersFromTransactionViewer = (viewer) => {
-  return { transactionViewer_byHash: (params) => viewer.byHash(...params ?? []) };
-};
-
-// src/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/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/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/engine/rpcMethodHandlersFromNetworkStakingViewer.ts
-var rpcMethodHandlersFromNetworkStakingViewer = (viewer) => {
-  return { networkStakeViewer_active: (params) => viewer.active(...params ?? []) };
-};
-
-// src/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/engine/rpcMethodHandlersFromSigner.ts
-var rpcMethodHandlersFromSigner = (signer) => {
-  return {
-    xyoSigner_address: (params) => signer.address(...params ?? []),
-    xyoSigner_sign: (params) => signer.sign(...params ?? [])
-  };
-};
-
-// src/provider/datalake/JsonRpcDataLakeViewer.ts
-import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
-import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-
-// src/types/DataLakePageRpc.ts
-var DataLakesPageMethodPrefix = "xyoDataLakes";
-var DataLakesGetMethod = `${DataLakesPageMethodPrefix}_get`;
-var DataLakesInsertMethod = `${DataLakesPageMethodPrefix}_insert`;
-
-// src/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/types/JsonRpc.ts
-var jsonrpc = "2.0";
-
-// src/types/NetworkStakeViewerRpc.ts
-var NetworkStakeViewerRpcNamespace = "networkStakeViewer";
-
-// src/types/NetworkStakingStepRewardsByPositionViewerRpc.ts
-var NetworkStakingStepRewardsByPositionViewerRpcNamespace = "networkStakingStepRewardsByPositionViewer";
-
-// src/types/NetworkStakingStepRewardsByStakerViewerRpc.ts
-var NetworkStakingStepRewardsByStakerViewerRpcNamespace = "networkStakingStepRewardsByStakerViewer";
-
-// src/types/NetworkStakingStepRewardsByStepViewerRpc.ts
-var NetworkStakingStepRewardsByStepViewerRpcNamespace = "networkStakingStepRewardsByStepViewer";
-
-// src/types/NetworkStakingStepRewardsTotalViewerRpc.ts
-var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepRewardsTotalViewer";
-
-// src/types/NetworkStakingStepRewardsViewerRpc.ts
-var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
-
-// src/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-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/types/schema/BlockViewerRpcSchemas.ts
-import { HashZod } from "@ariestools/sdk";
-import { HashMetaZod, PayloadZodLoose } from "@xyo-network/sdk";
-import { SignedHydratedBlockWithHashMetaZod, XL1BlockNumberZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z2 } from "zod/mini";
-var WithHashMetaPayloadZodLoose = z2.extend(PayloadZodLoose, HashMetaZod.shape);
-var BlockViewerRpcSchemas = {
-  blockViewer_blocksByNumber: {
-    params: {
-      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/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-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/types/schema/FinalizationViewerRpcSchemas.ts
-import { SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod2 } from "@xyo-network/xl1-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/types/schema/MempoolRunnerRpcSchemas.ts
-import { HashZod as HashZod3 } from "@ariestools/sdk";
-import { SignedHydratedBlockZod, SignedHydratedTransactionZod } from "@xyo-network/xl1-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/types/schema/MempoolViewerRpcSchemas.ts
-import {
-  PendingBlocksOptionsZod,
-  PendingTransactionsOptionsZod,
-  SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3,
-  SignedHydratedTransactionWithHashMetaZod
-} from "@xyo-network/xl1-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/types/schema/NetworkStakeViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@ariestools/sdk";
-import { BlockNumberZod } from "@xyo-network/xl1-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/types/schema/RewardsByPositionViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod3 } from "@ariestools/sdk";
-import { asAttoXL1, RewardsRangeOptionsZod } from "@xyo-network/xl1-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/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-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/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-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/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-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/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-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/types/schema/StakeViewerRpcSchemas.ts
-import { XyoAddressZod as XyoAddressZod5 } from "@xyo-network/sdk";
-import { JsonToStakeZod, StakeToJsonZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z14 } from "zod";
-
-// src/types/schema/NoArgsZod.ts
-import { z as z13 } from "zod";
-var NoArgsZod = z13.tuple([]).default([]);
-
-// src/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/types/schema/StepRewardsViewerRpcSchemas.ts
-var NetworkStakingStepRewardsViewerRpcSchemas = {};
-
-// src/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-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/types/schema/TimeSyncViewerRpcSchema.ts
-import { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-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/types/schema/TransactionViewerRpcSchema.ts
-import { HashZod as HashZod4 } from "@ariestools/sdk";
-import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2 } from "@xyo-network/xl1-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/types/schema/XyoPermissionsRpcSchemas.ts
-import {
-  InvokerPermissionZod,
-  PermissionRequestZod,
-  RequestedPermissionZod
-} from "@xyo-network/xl1-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/types/schema/XyoRunnerRpcSchemas.ts
-import { HashToJsonZod, JsonToHashZod } from "@ariestools/sdk";
-import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-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/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/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-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/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/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/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/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-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/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
-import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-
-// src/provider/JsonRpcProvider.ts
-import { isDefined as isDefined5 } from "@ariestools/sdk";
-import { AbstractCreatableProvider } from "@xyo-network/xl1-protocol-sdk";
-
-// src/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/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/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/transport/PostMessage/bus/implementations/PostMessage.ts
-import { isDefined as isDefined3 } from "@ariestools/sdk";
-
-// src/transport/PostMessage/bus/validators/hasSessionId.ts
-var hasSessionId = (message) => {
-  return typeof message === "object" && message !== null && "sessionId" in message && typeof message.sessionId === "string";
-};
-
-// src/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/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/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/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/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/provider/viewer/JsonRpcViewer.ts
-var AbstractJsonRpcViewer = class extends AbstractJsonRpcProvider {
-};
-
-// src/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/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/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
-import { assertEx as assertEx2 } from "@ariestools/sdk";
-import { BlockViewerMoniker as BlockViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import {
-  calculateBlockRate,
-  calculateStepSizeRate,
-  calculateTimeRate,
-  creatableProvider as creatableProvider2
-} from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
-import { isDefined as isDefined6 } from "@ariestools/sdk";
-import { BlockViewerMoniker } from "@xyo-network/xl1-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/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/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
-import { FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider3 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewerMethods.ts
-import { FinalizationViewerMoniker } from "@xyo-network/xl1-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/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/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
-import { MempoolViewerMoniker as MempoolViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider4 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts
-import { MempoolViewerMoniker } from "@xyo-network/xl1-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/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/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
-import {
-  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider5 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts
-import { NetworkStakeStepRewardsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-var JsonRpcNetworkStakeStepRewardsViewerMethods = class extends AbstractJsonRpcViewer {
-  moniker = NetworkStakeStepRewardsViewerMoniker;
-  schemas() {
-    return NetworkStakingStepRewardsViewerRpcSchemas;
-  }
-};
-
-// src/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/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
-import {
-  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
-  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider6 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
-import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
-var JsonRpcNetworkStakeViewerMethods = class extends AbstractJsonRpcViewer {
-  moniker = NetworkStakeViewerMoniker;
-  async active(blockNumber) {
-    return await this.transport.sendRequest("networkStakeViewer_active", [blockNumber]);
-  }
-  schemas() {
-    return NetworkStakeViewerRpcSchemas;
-  }
-};
-
-// src/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/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
-import { StakeTotalsViewerMoniker as StakeTotalsViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider7 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts
-import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-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/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/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewer.ts
-import {
-  StakeEventsViewerMoniker,
-  StakeViewerMoniker as StakeViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider8 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcStakeViewer/JsonRpcStakeViewerMethods.ts
-import { StakeViewerMoniker } from "@xyo-network/xl1-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/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/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
-import { TimeSyncViewerMoniker as TimeSyncViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider9 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
-import { TimeSyncViewerMoniker } from "@xyo-network/xl1-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/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/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-lib";
-import { creatableProvider as creatableProvider10 } from "@xyo-network/xl1-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/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-lib";
-import { creatableProvider as creatableProvider11 } from "@xyo-network/xl1-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/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/provider/datalake/JsonRpcDataLakeViewer.ts
-var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
-};
-__publicField(JsonRpcDataLakeViewer, "dependencies", []);
-JsonRpcDataLakeViewer = __decorateClass([
-  creatableProvider12()
-], JsonRpcDataLakeViewer);
-
-// src/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/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-import { MempoolRunnerMoniker as MempoolRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
-import { elevatedTransaction, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
-
-// src/provider/runner/JsonRpcRunner.ts
-var AbstractJsonRpcRunner = class extends AbstractJsonRpcProvider {
-};
-
-// src/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/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/provider/runner/JsonRpcXyoRunner.ts
-import { MempoolRunnerMoniker as MempoolRunnerMoniker3, XyoRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
-import { creatableProvider as creatableProvider14 } from "@xyo-network/xl1-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/provider/signer/JsonRpcXyoSigner.ts
-import { asSignedHydratedTransactionWithHashMeta, XyoSignerMoniker as XyoSignerMoniker2 } from "@xyo-network/xl1-protocol-lib";
-
-// src/provider/signer/JsonRpcXyoSignerMethods.ts
-import { XyoSignerMoniker } from "@xyo-network/xl1-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/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/engine-node/composedRpcEngineFromConnection.ts
-import {
-  JsonRpcEngineV2,
-  JsonRpcServer as JsonRpcServer2
-} from "@metamask/json-rpc-engine/v2";
-
-// src/engine-node/middleware/createHandlerMiddleware.ts
-import { createScaffoldMiddleware } from "@metamask/json-rpc-engine/v2";
-var buildHandlerScaffold = (handlers) => {
-  const scaffold = {};
-  for (const [method, handler] of Object.entries(handlers)) {
-    if (handler === void 0) continue;
-    scaffold[method] = async ({ context }) => {
-      const schema = context.assertGet("schema");
-      const params = context.assertGet("params");
-      const result = await handler(params);
-      return schema.result.to.parse(result);
-    };
-  }
-  return createScaffoldMiddleware(scaffold);
-};
-var createTypedHandlerMiddleware = (_schemas, handlers) => buildHandlerScaffold(handlers);
-
-// src/engine-node/middleware/createLoggingMiddleware.ts
-var createLoggingMiddleware = (logger) => async ({ request, next }) => {
-  try {
-    return await next();
-  } catch (error) {
-    logger?.error(`RPC ${request.method} failed`, error);
-    throw error;
-  }
-};
-
-// src/engine-node/middleware/createMethodNotFoundMiddleware.ts
-var createMethodNotFoundMiddleware = () => ({ request }) => {
-  throw new Error(`${JsonRpcErrorCodes.MethodNotFound.message} (${request.method})`);
-};
-
-// src/engine-node/middleware/createValidationMiddleware.ts
-var createValidationMiddleware = (schemas) => ({
-  request,
-  context,
-  next
-}) => {
-  const schema = schemas[request.method];
-  if (schema === void 0) return next();
-  let requestSchema = requestSchemas[request.method];
-  if (requestSchema === void 0) {
-    requestSchema = createRequestSchema(request.method, schema.params.from);
-    requestSchemas[request.method] = requestSchema;
-  }
-  const parsed = requestSchema.safeParse(request);
-  if (!parsed.success) {
-    throw new Error(parsed.error.message);
-  }
-  context.set("schema", schema);
-  context.set("params", parsed.data.params);
-  return next();
-};
-
-// src/engine-node/composedRpcEngineFromConnection.ts
-var buildTypedSubEngine = (schemas, handlers) => JsonRpcEngineV2.create({
-  middleware: [
-    createValidationMiddleware(schemas),
-    createTypedHandlerMiddleware(schemas, handlers)
-  ]
-});
-var composedRpcEngineFromConnection = (connection, logger) => {
-  const { runner, viewer } = connection;
-  const subEngines = [];
-  if (runner) {
-    subEngines.push(buildTypedSubEngine(XyoRunnerRpcSchemas, rpcMethodHandlersFromRunner(runner)));
-  }
-  if (viewer) {
-    subEngines.push(buildTypedSubEngine(XyoViewerRpcSchemas, rpcMethodHandlersFromViewer(viewer)));
-  }
-  const accountBalanceViewer = viewer?.account?.balance;
-  if (accountBalanceViewer) {
-    subEngines.push(buildTypedSubEngine(
-      AccountBalanceViewerRpcSchemas,
-      rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
-    ));
-  }
-  const blockViewer = viewer?.block;
-  if (blockViewer) {
-    subEngines.push(buildTypedSubEngine(
-      BlockViewerRpcSchemas,
-      rpcMethodHandlersFromBlockViewer(blockViewer)
-    ));
-  }
-  const finalizationViewer = viewer?.finalization;
-  if (finalizationViewer) {
-    subEngines.push(buildTypedSubEngine(
-      FinalizationViewerRpcSchemas,
-      rpcMethodHandlersFromFinalizationViewer(finalizationViewer)
-    ));
-  }
-  const mempoolViewer = viewer?.mempool;
-  if (mempoolViewer) {
-    subEngines.push(buildTypedSubEngine(
-      MempoolViewerRpcSchemas,
-      rpcMethodHandlersFromMempoolViewer(mempoolViewer)
-    ));
-  }
-  const timeSyncViewer = viewer?.time;
-  if (timeSyncViewer) {
-    subEngines.push(buildTypedSubEngine(
-      TimeSyncViewerRpcSchemas,
-      rpcMethodHandlersFromTimeSyncViewer(timeSyncViewer)
-    ));
-  }
-  const transactionViewer = viewer?.transaction;
-  if (transactionViewer) {
-    subEngines.push(buildTypedSubEngine(
-      TransactionViewerRpcSchemas,
-      rpcMethodHandlersFromTransactionViewer(transactionViewer)
-    ));
-  }
-  const mempoolRunner = runner?.mempool;
-  if (mempoolRunner) {
-    subEngines.push(buildTypedSubEngine(
-      MempoolRunnerRpcSchemas,
-      rpcMethodHandlersFromMempoolRunner(mempoolRunner)
-    ));
-  }
-  const networkStakeViewer = viewer?.networkStake;
-  if (networkStakeViewer?.stepRewards?.position) {
-    subEngines.push(buildTypedSubEngine(
-      NetworkStakingStepRewardsByPositionViewerRpcSchemas,
-      rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
-    ));
-  }
-  const middleware = [
-    createLoggingMiddleware(logger),
-    ...subEngines.map((engine) => engine.asMiddleware()),
-    createMethodNotFoundMiddleware()
-  ];
-  return JsonRpcEngineV2.create({ middleware });
-};
-var composedRpcServerFromConnection = (connection, logger) => {
-  const engine = composedRpcEngineFromConnection(connection, logger);
-  return new JsonRpcServer2({ engine });
-};
-
-// src/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/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
-};
+// src/index.ts
+export * from "@xyo-network/xl1-sdk/rpc";
 //# sourceMappingURL=index.mjs.map