@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/protocol-lib.mjs

@@ -0,0 +1,600 @@
+// src/modules/protocol-lib/address/derivedReceiveAddress.ts
+import { isDefined, toAddress } from "@ariestools/sdk";
+import { keccak256 } from "ethers";
+function derivedReceiveAddress(address, scope) {
+  const encoder = new TextEncoder();
+  const addressKey = encoder.encode(isDefined(scope) ? `${scope}|${address}` : address);
+  const hash = keccak256(addressKey);
+  return toAddress(hash.slice(-40), { prefix: false });
+}
+
+// src/modules/protocol-lib/address/rewardAddressFromStepIdentity.ts
+import { toAddress as toAddress2 } from "@ariestools/sdk";
+import { keccak256 as keccak2562 } from "ethers";
+import { StepSizes } from "#protocol-model";
+function rewardAddressFromStepIdentity({ block, step }) {
+  const resolvedStepSize = step < StepSizes.length ? StepSizes[step] : step;
+  const encoder = new TextEncoder();
+  const addressKey = encoder.encode(`${block}|${resolvedStepSize}`);
+  const hash = keccak2562(addressKey);
+  return toAddress2(hash.slice(-40), { prefix: false });
+}
+var completedStepRewardAddress = rewardAddressFromStepIdentity;
+
+// src/modules/protocol-lib/address/sentinelAddressFromSchema.ts
+import { isDefined as isDefined2, toAddress as toAddress3 } from "@ariestools/sdk";
+import { keccak256 as keccak2563 } from "ethers";
+function sentinelAddressFromSchema(schema, payloadHash) {
+  const seed = isDefined2(payloadHash) ? `${schema}|${payloadHash}` : schema;
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(seed);
+  const hash = keccak2563(encoded);
+  return toAddress3(hash.slice(-40), { prefix: false });
+}
+
+// src/modules/protocol-lib/network/Status.ts
+import { asSchema, isPayloadOfSchemaType } from "@xyo-network/sdk";
+var NetworkStatusSchema = asSchema("network.xyo.chain.status", true);
+var isNetworkStatus = isPayloadOfSchemaType(NetworkStatusSchema);
+
+// src/modules/protocol-lib/providers/DataLake/isSchemaAllowed.ts
+function isSchemaAllowed(schema, allowedSchemas, disallowedSchemas) {
+  if (allowedSchemas && !allowedSchemas.includes(schema)) {
+    return false;
+  }
+  if (disallowedSchemas?.includes(schema) === true) {
+    return false;
+  }
+  return true;
+}
+
+// src/modules/protocol-lib/providers/DataLake/Runner.ts
+var DataLakeRunnerMoniker = "DataLakeRunner";
+
+// src/modules/protocol-lib/providers/DataLake/Viewer.ts
+var DataLakeViewerMoniker = "DataLakeViewer";
+
+// src/modules/protocol-lib/providers/signer/XyoSigner.ts
+var XyoSignerMoniker = "XyoSigner";
+
+// src/modules/protocol-lib/providers/XyoConnection.ts
+var XyoConnectionMoniker = "XyoConnection";
+
+// src/modules/protocol-lib/providers/XyoGateway.ts
+var XyoGatewayMoniker = "XyoGateway";
+
+// src/modules/protocol-lib/providers/XyoGatewayRunner.ts
+var XyoGatewayRunnerMoniker = "XyoGatewayRunner";
+
+// src/modules/protocol-lib/providers/XyoRunner.ts
+var XyoRunnerMoniker = "XyoRunner";
+
+// src/modules/protocol-lib/runners/Block.ts
+var BlockRunnerMoniker = "BlockRunner";
+
+// src/modules/protocol-lib/runners/BlockPublish.ts
+var BlockPublishRunnerMoniker = "BlockPublishRunner";
+
+// src/modules/protocol-lib/runners/ChainStatePublish.ts
+var ChainStatePublishRunnerMoniker = "ChainStatePublishRunner";
+
+// src/modules/protocol-lib/runners/DataLakePublish.ts
+var DataLakePublishRunnerMoniker = "DataLakePublishRunner";
+
+// src/modules/protocol-lib/runners/DeadLetterQueue.ts
+var DeadLetterQueueRunnerMoniker = "DeadLetterQueueRunner";
+
+// src/modules/protocol-lib/runners/Finalization.ts
+var FinalizationRunnerMoniker = "FinalizationRunner";
+
+// src/modules/protocol-lib/runners/IndexPublish.ts
+var IndexPublishRunnerMoniker = "IndexPublishRunner";
+
+// src/modules/protocol-lib/runners/Mempool.ts
+var MempoolRunnerMoniker = "MempoolRunner";
+var DEFAULT_MAX_EXP_AHEAD = 1e3;
+
+// src/modules/protocol-lib/status/SystemStatus.ts
+var SystemStatusRunnerMoniker = "SystemStatusRunner";
+var SystemStatusViewerMoniker = "SystemStatusViewer";
+var SystemStatusPublisherMoniker = "SystemStatusPublisher";
+
+// src/modules/protocol-lib/summary/BlocksStepSummary.ts
+import { AsObjectFactory } from "@ariestools/sdk";
+import {
+  asSchema as asSchema2,
+  isPayloadOfSchemaType as isPayloadOfSchemaType2,
+  isStorageMeta
+} from "@xyo-network/sdk";
+var BlocksStepSummarySchema = asSchema2("network.xyo.step.summary.blocks", true);
+var isBlocksStepSummary = isPayloadOfSchemaType2(BlocksStepSummarySchema);
+var asBlocksStepSummary = AsObjectFactory.create(isBlocksStepSummary);
+var isBlocksStepSummaryWithStorageMeta = (value) => {
+  return isBlocksStepSummary(value) && isStorageMeta(value);
+};
+var asBlocksStepSummaryWithStorageMeta = AsObjectFactory.create(isBlocksStepSummaryWithStorageMeta);
+
+// src/modules/protocol-lib/summary/stepPlacement.ts
+import { asXL1BlockNumber, StepSizes as StepSizes2 } from "#protocol-model";
+function stepPlacementForBlockNumber(blockNumber, stepSize) {
+  const stepLevel = StepSizes2.indexOf(asXL1BlockNumber(stepSize, true));
+  if (stepLevel === -1) return void 0;
+  const stepIndex = (blockNumber + 1) / stepSize - 1;
+  return Number.isSafeInteger(stepIndex) && stepIndex >= 0 ? { stepIndex, stepLevel } : void 0;
+}
+async function resolveStepPlacement(blockViewer, hash, stepSize) {
+  const block = await blockViewer.blockByHash(hash);
+  if (!block) return void 0;
+  return stepPlacementForBlockNumber(block[0].block, stepSize);
+}
+
+// src/modules/protocol-lib/summary/StepSummary.ts
+import {
+  asSchema as asSchema3
+} from "@xyo-network/sdk";
+var StepSummarySchema = asSchema3("network.xyo.step.summary", true);
+
+// src/modules/protocol-lib/transaction/elevatedPayloads.ts
+import { isAllowedBlockPayload } from "#protocol-model";
+var ELEVATE_OPCODE = "elevate";
+function elevatedPayloads([tx, payloads]) {
+  const opCodes = (tx.script ?? []).filter((operation) => operation.startsWith(`${ELEVATE_OPCODE}|`));
+  const elevatedPayloads2 = [];
+  for (const opCode of opCodes) {
+    const [code, hash] = opCode.split("|");
+    if (code === ELEVATE_OPCODE) {
+      const elevatedPayload = payloads.find((payload) => payload._hash === hash);
+      if (isAllowedBlockPayload(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
+      }
+    }
+  }
+  if (opCodes.length === elevatedPayloads2.length) {
+    return elevatedPayloads2;
+  }
+  throw new Error("Not all elevated payloads could be found in the transaction payloads");
+}
+
+// src/modules/protocol-lib/transaction/script.ts
+import {
+  asHash,
+  assertEx,
+  filterAs
+} from "@ariestools/sdk";
+import { isHashMeta } from "@xyo-network/sdk";
+import { isAllowedBlockPayload as isAllowedBlockPayload2 } from "#protocol-model";
+var tryExtractElevatedHashesFromScript = (strings) => {
+  const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|", 2)[1]);
+  return filterAs(hashes, (h) => asHash(h));
+};
+var extractElevatedHashesFromScript = (strings) => {
+  const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|", 2)[1]);
+  const filtered = filterAs(hashes, (h) => asHash(h));
+  assertEx(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  return filtered;
+};
+var tryExtractElevatedHashes = (tx) => {
+  const [bw, payloads] = tx;
+  const { script } = bw;
+  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
+  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayload2).filter(isHashMeta);
+};
+var elevatedTransaction = (tx) => (
+  // The cast bridges the loose-object payload typing; the elevated payloads are a subset of the originals.
+  [tx[0], tryExtractElevatedHashes(tx)]
+);
+var extractElevatedHashes = (tx) => {
+  const [bw, payloads] = tx;
+  const { script } = bw;
+  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
+  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayload2).filter(isHashMeta);
+  assertEx(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  return filtered;
+};
+
+// src/modules/protocol-lib/validation/block/error.ts
+import {
+  HashZod as HashZod2,
+  HexZod,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import { z as z2 } from "zod";
+
+// src/modules/protocol-lib/validation/error.ts
+import {
+  HashZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@ariestools/sdk";
+import { z } from "zod";
+var ValidationErrorZod = z.object({
+  hash: HashZod,
+  message: z.string().optional(),
+  name: z.string(),
+  value: z.unknown()
+}).loose();
+var ValidationError = class extends Error {
+  cause;
+  hash;
+  message;
+  value;
+  constructor(hash, value, message, cause) {
+    super(message);
+    this.hash = hash;
+    this.message = message;
+    this.name = this.constructor.name;
+    this.value = value;
+    this.cause = cause;
+  }
+};
+var isValidationError = zodIsFactory(ValidationErrorZod);
+var asValidationError = zodAsFactory(ValidationErrorZod, "ValidationError");
+var toValidationError = zodToFactory(ValidationErrorZod, "ValidationError");
+
+// src/modules/protocol-lib/validation/block/error.ts
+var BlockValidationErrorZod = ValidationErrorZod.extend({ name: z2.literal("BlockValidationError") }).loose();
+var BlockValidationError = class extends ValidationError {
+};
+var isBlockValidationError = zodIsFactory2(BlockValidationErrorZod);
+var asBlockValidationError = zodAsFactory2(BlockValidationErrorZod, "BlockValidationError");
+var toBlockValidationError = zodToFactory2(BlockValidationErrorZod, "BlockValidationError");
+var HydratedBlockValidationErrorZod = ValidationErrorZod.extend({ name: z2.literal("HydratedBlockValidationError") }).loose();
+var HydratedBlockValidationError = class extends ValidationError {
+};
+var isHydratedBlockValidationError = zodIsFactory2(HydratedBlockValidationErrorZod);
+var asHydratedBlockValidationError = zodAsFactory2(HydratedBlockValidationErrorZod, "HydratedBlockValidationError");
+var toHydratedBlockValidationError = zodToFactory2(HydratedBlockValidationErrorZod, "HydratedBlockValidationError");
+var HydratedBlockStateValidationErrorZod = ValidationErrorZod.extend({
+  chainId: HexZod,
+  name: z2.literal("HydratedBlockStateValidationError"),
+  offendingTransactionHashes: z2.array(HashZod2).optional()
+}).loose();
+var HydratedBlockStateValidationError = class extends ValidationError {
+  chainId;
+  offendingTransactionHashes;
+  constructor(hash, chainId, value, message, cause, offendingTransactionHashes) {
+    super(hash, value, message, cause);
+    this.chainId = chainId;
+    this.offendingTransactionHashes = offendingTransactionHashes;
+  }
+};
+var isHydratedBlockStateValidationError = zodIsFactory2(HydratedBlockStateValidationErrorZod);
+var asHydratedBlockStateValidationError = zodAsFactory2(HydratedBlockStateValidationErrorZod, "HydratedBlockStateValidationError");
+var toHydratedBlockStateValidationError = zodToFactory2(HydratedBlockStateValidationErrorZod, "HydratedBlockStateValidationError");
+
+// src/modules/protocol-lib/validation/boundwitness/error.ts
+var BoundWitnessValidationError = class extends ValidationError {
+};
+var isBoundWitnessValidationError = (error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === BoundWitnessValidationError.constructor.name;
+};
+var HydratedBoundWitnessValidationError = class extends ValidationError {
+};
+var isHydratedBoundWitnessValidationError = (error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedBoundWitnessValidationError.constructor.name;
+};
+
+// src/modules/protocol-lib/validation/payload/error.ts
+var InBlockPayloadValidationError = class extends ValidationError {
+  block;
+  constructor(hash, block, value, message, cause) {
+    super(hash, value, message, cause);
+    this.block = block;
+  }
+};
+var isInBlockPayloadValidationError = (error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === InBlockPayloadValidationError.constructor.name;
+};
+
+// src/modules/protocol-lib/validation/transaction/error.ts
+var HydratedTransactionValidationError = class extends ValidationError {
+};
+var isHydratedTransactionValidationError = (error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedTransactionValidationError.constructor.name;
+};
+
+// src/modules/protocol-lib/viewers/Block.ts
+var BlockViewerMoniker = "BlockViewer";
+
+// src/modules/protocol-lib/viewers/BlockInvalidation.ts
+import { zodIsFactory as zodIsFactory3 } from "@ariestools/sdk";
+import { z as z3 } from "zod";
+import { ChainQualifiedHeadConfigZod, ChainQualifiedRangeConfigZod } from "#protocol-model";
+var BlockInvalidationConfigFieldsZod = z3.object({
+  state: z3.boolean().optional(),
+  value: z3.boolean().optional()
+});
+var BlockInvalidationConfigZod = z3.union([
+  BlockInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
+  BlockInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
+  BlockInvalidationConfigFieldsZod,
+  z3.object({})
+]);
+var isBlockInvalidationConfig = zodIsFactory3(BlockInvalidationConfigZod);
+var BlockInvalidationViewerMoniker = "BlockInvalidationViewer";
+
+// src/modules/protocol-lib/viewers/BlockReward.ts
+var BlockRewardViewerMoniker = "BlockRewardViewer";
+
+// src/modules/protocol-lib/viewers/BlockValidation.ts
+import { zodIsFactory as zodIsFactory4 } from "@ariestools/sdk";
+import { z as z4 } from "zod";
+import { ChainQualifiedHeadConfigZod as ChainQualifiedHeadConfigZod2, ChainQualifiedRangeConfigZod as ChainQualifiedRangeConfigZod2 } from "#protocol-model";
+var BlockValidationConfigFieldsZod = z4.object({
+  value: z4.boolean().optional(),
+  state: z4.boolean().optional()
+});
+var BlockValidationConfigZod = z4.union([
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod2.shape),
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod2.shape),
+  BlockValidationConfigFieldsZod,
+  z4.object({})
+]);
+var isBlockValidationConfig = zodIsFactory4(BlockValidationConfigZod);
+var BlockValidationViewerMoniker = "BlockValidationViewer";
+
+// src/modules/protocol-lib/viewers/ChainContract.ts
+var ChainContractViewerMoniker = "ChainContractViewer";
+
+// src/modules/protocol-lib/viewers/ChainStakeViewer.ts
+var ChainStakeViewerMoniker = "ChainStakeViewer";
+
+// src/modules/protocol-lib/viewers/ChainState.ts
+var ChainStateViewerMoniker = "ChainStateViewer";
+
+// src/modules/protocol-lib/viewers/DeadLetterQueue.ts
+import { HashZod as HashZod3 } from "@ariestools/sdk";
+import { z as z5 } from "zod/mini";
+var RejectedBlocksOptionsZod = z5.object({
+  cursor: z5.optional(HashZod3),
+  limit: z5.optional(z5.int().check(z5.positive())),
+  rejector: z5.optional(z5.string())
+});
+var RejectedTransactionsOptionsZod = z5.object({
+  cursor: z5.optional(HashZod3),
+  limit: z5.optional(z5.int().check(z5.positive())),
+  rejector: z5.optional(z5.string())
+});
+var DeadLetterQueueViewerMoniker = "DeadLetterQueueViewer";
+
+// src/modules/protocol-lib/viewers/Finalization.ts
+var FinalizationViewerMoniker = "FinalizationViewer";
+
+// src/modules/protocol-lib/viewers/IndexViewer.ts
+var IndexViewerMoniker = "IndexViewer";
+
+// src/modules/protocol-lib/viewers/Mempool.ts
+import { HashZod as HashZod4 } from "@ariestools/sdk";
+import { z as z6 } from "zod/mini";
+import { XL1BlockRangeZod } from "#protocol-model";
+var PendingTransactionsOptionsZod = z6.object({
+  cursor: z6.optional(HashZod4),
+  limit: z6.optional(z6.int().check(z6.positive())),
+  window: z6.optional(XL1BlockRangeZod)
+});
+var PendingBlocksOptionsZod = z6.object({
+  cursor: z6.optional(HashZod4),
+  limit: z6.optional(z6.int().check(z6.positive())),
+  window: z6.optional(XL1BlockRangeZod)
+});
+var MempoolViewerMoniker = "MempoolViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/NetworkStakeViewer.ts
+var NetworkStakeViewerMoniker = "NetworkStakeViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/Rewards/ByPositionViewer.ts
+var NetworkStakeStepRewardsByPositionViewerMoniker = "NetworkStakeStepRewardsByPositionViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/Rewards/ByStakerViewer.ts
+var NetworkStakeStepRewardsByStakerViewerMoniker = "NetworkStakeStepRewardsByStakerViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/Rewards/ByStepViewer.ts
+var NetworkStakeStepRewardsByStepViewerMoniker = "NetworkStakeStepRewardsByStepViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/Rewards/TotalViewer.ts
+var NetworkStakeStepRewardsTotalViewerMoniker = "NetworkStakeStepRewardsTotalViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStake/Rewards/Viewer.ts
+var NetworkStakeStepRewardsViewerMoniker = "NetworkStakeStepRewardsViewer";
+
+// src/modules/protocol-lib/viewers/NetworkStakeStepReward.ts
+var NetworkStakeStepRewardViewerMoniker = "NetworkStakeStepRewardViewer";
+
+// src/modules/protocol-lib/viewers/Stake.ts
+var StakeViewerMoniker = "StakeViewer";
+var StakeRunnerMoniker = "StakeRunner";
+
+// src/modules/protocol-lib/viewers/StakeEvents.ts
+var StakeEventNames = ["StakeAdded", "StakeRemoved", "StakeWithdrawn"];
+var StakeEventsViewerMoniker = "StakeEventsViewer";
+
+// src/modules/protocol-lib/viewers/StakeTotals.ts
+var StakeTotalsViewerMoniker = "StakeTotalsViewer";
+
+// src/modules/protocol-lib/viewers/StepStake.ts
+var StepStakeViewerMoniker = "StepStakeViewer";
+
+// src/modules/protocol-lib/viewers/StepViewer.ts
+var StepViewerMoniker = "StepViewer";
+
+// src/modules/protocol-lib/viewers/Sync.ts
+var SyncViewerMoniker = "SyncViewer";
+
+// src/modules/protocol-lib/viewers/TimeSync.ts
+var TimeSyncViewerMoniker = "TimeSyncViewer";
+
+// src/modules/protocol-lib/viewers/Transaction.ts
+var TransactionViewerMoniker = "TransactionViewer";
+
+// src/modules/protocol-lib/viewers/TransactionInvalidation.ts
+import { zodIsFactory as zodIsFactory5 } from "@ariestools/sdk";
+import { z as z7 } from "zod";
+import { ChainQualifiedHeadConfigZod as ChainQualifiedHeadConfigZod3, ChainQualifiedRangeConfigZod as ChainQualifiedRangeConfigZod3 } from "#protocol-model";
+var TransactionInvalidationConfigFieldsZod = z7.object({
+  state: z7.boolean().optional(),
+  value: z7.boolean().optional()
+});
+var TransactionInvalidationConfigZod = z7.union([
+  TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod3.shape),
+  TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod3.shape),
+  TransactionInvalidationConfigFieldsZod,
+  z7.object({})
+]);
+var isTransactionInvalidationConfig = zodIsFactory5(TransactionInvalidationConfigZod);
+var TransactionInvalidationViewerMoniker = "TransactionInvalidationViewer";
+
+// src/modules/protocol-lib/viewers/TransactionValidation.ts
+import { zodIsFactory as zodIsFactory6 } from "@ariestools/sdk";
+import { z as z8 } from "zod";
+import { ChainQualifiedHeadConfigZod as ChainQualifiedHeadConfigZod4, ChainQualifiedRangeConfigZod as ChainQualifiedRangeConfigZod4 } from "#protocol-model";
+var TransactionValidationConfigFieldsZod = z8.object({
+  value: z8.boolean().optional(),
+  state: z8.boolean().optional()
+});
+var TransactionValidationConfigZod = z8.union([
+  TransactionValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod4.shape),
+  TransactionValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod4.shape),
+  TransactionValidationConfigFieldsZod,
+  z8.object({})
+]);
+var isTransactionValidationConfig = zodIsFactory6(TransactionValidationConfigZod);
+var TransactionValidationViewerMoniker = "TransactionValidationViewer";
+
+// src/modules/protocol-lib/viewers/TransferBalance.ts
+var TransferBalanceViewerMoniker = "TransferBalanceViewer";
+
+// src/modules/protocol-lib/viewers/WindowedBlock.ts
+var WindowedBlockViewerMoniker = "WindowedBlockViewer";
+
+// src/modules/protocol-lib/viewers/XyoViewer.ts
+var XyoViewerMoniker = "XyoViewer";
+
+// src/modules/protocol-lib/index.ts
+export * from "#protocol-model";
+export {
+  BlockInvalidationConfigFieldsZod,
+  BlockInvalidationConfigZod,
+  BlockInvalidationViewerMoniker,
+  BlockPublishRunnerMoniker,
+  BlockRewardViewerMoniker,
+  BlockRunnerMoniker,
+  BlockValidationConfigFieldsZod,
+  BlockValidationConfigZod,
+  BlockValidationError,
+  BlockValidationErrorZod,
+  BlockValidationViewerMoniker,
+  BlockViewerMoniker,
+  BlocksStepSummarySchema,
+  BoundWitnessValidationError,
+  ChainContractViewerMoniker,
+  ChainStakeViewerMoniker,
+  ChainStatePublishRunnerMoniker,
+  ChainStateViewerMoniker,
+  DEFAULT_MAX_EXP_AHEAD,
+  DataLakePublishRunnerMoniker,
+  DataLakeRunnerMoniker,
+  DataLakeViewerMoniker,
+  DeadLetterQueueRunnerMoniker,
+  DeadLetterQueueViewerMoniker,
+  FinalizationRunnerMoniker,
+  FinalizationViewerMoniker,
+  HydratedBlockStateValidationError,
+  HydratedBlockStateValidationErrorZod,
+  HydratedBlockValidationError,
+  HydratedBlockValidationErrorZod,
+  HydratedBoundWitnessValidationError,
+  HydratedTransactionValidationError,
+  InBlockPayloadValidationError,
+  IndexPublishRunnerMoniker,
+  IndexViewerMoniker,
+  MempoolRunnerMoniker,
+  MempoolViewerMoniker,
+  NetworkStakeStepRewardViewerMoniker,
+  NetworkStakeStepRewardsByPositionViewerMoniker,
+  NetworkStakeStepRewardsByStakerViewerMoniker,
+  NetworkStakeStepRewardsByStepViewerMoniker,
+  NetworkStakeStepRewardsTotalViewerMoniker,
+  NetworkStakeStepRewardsViewerMoniker,
+  NetworkStakeViewerMoniker,
+  NetworkStatusSchema,
+  PendingBlocksOptionsZod,
+  PendingTransactionsOptionsZod,
+  RejectedBlocksOptionsZod,
+  RejectedTransactionsOptionsZod,
+  StakeEventNames,
+  StakeEventsViewerMoniker,
+  StakeRunnerMoniker,
+  StakeTotalsViewerMoniker,
+  StakeViewerMoniker,
+  StepStakeViewerMoniker,
+  StepSummarySchema,
+  StepViewerMoniker,
+  SyncViewerMoniker,
+  SystemStatusPublisherMoniker,
+  SystemStatusRunnerMoniker,
+  SystemStatusViewerMoniker,
+  TimeSyncViewerMoniker,
+  TransactionInvalidationConfigFieldsZod,
+  TransactionInvalidationConfigZod,
+  TransactionInvalidationViewerMoniker,
+  TransactionValidationConfigFieldsZod,
+  TransactionValidationConfigZod,
+  TransactionValidationViewerMoniker,
+  TransactionViewerMoniker,
+  TransferBalanceViewerMoniker,
+  ValidationError,
+  ValidationErrorZod,
+  WindowedBlockViewerMoniker,
+  XyoConnectionMoniker,
+  XyoGatewayMoniker,
+  XyoGatewayRunnerMoniker,
+  XyoRunnerMoniker,
+  XyoSignerMoniker,
+  XyoViewerMoniker,
+  asBlockValidationError,
+  asBlocksStepSummary,
+  asBlocksStepSummaryWithStorageMeta,
+  asHydratedBlockStateValidationError,
+  asHydratedBlockValidationError,
+  asValidationError,
+  completedStepRewardAddress,
+  derivedReceiveAddress,
+  elevatedPayloads,
+  elevatedTransaction,
+  extractElevatedHashes,
+  extractElevatedHashesFromScript,
+  isBlockInvalidationConfig,
+  isBlockValidationConfig,
+  isBlockValidationError,
+  isBlocksStepSummary,
+  isBlocksStepSummaryWithStorageMeta,
+  isBoundWitnessValidationError,
+  isHydratedBlockStateValidationError,
+  isHydratedBlockValidationError,
+  isHydratedBoundWitnessValidationError,
+  isHydratedTransactionValidationError,
+  isInBlockPayloadValidationError,
+  isNetworkStatus,
+  isSchemaAllowed,
+  isTransactionInvalidationConfig,
+  isTransactionValidationConfig,
+  isValidationError,
+  resolveStepPlacement,
+  rewardAddressFromStepIdentity,
+  sentinelAddressFromSchema,
+  stepPlacementForBlockNumber,
+  toBlockValidationError,
+  toHydratedBlockStateValidationError,
+  toHydratedBlockValidationError,
+  toValidationError,
+  tryExtractElevatedHashes,
+  tryExtractElevatedHashesFromScript
+};
+//# sourceMappingURL=protocol-lib.mjs.map