@xyo-network/xl1-protocol-sdk 1.26.23 → 1.26.25

package/dist/neutral/test/index.mjs

@@ -634,130 +634,210 @@ var TelemetryConfigZod = z14.object({
 // src/config/Validation.ts
 import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry11, z as z15 } from "zod";
-var ValidationConfigZod = z15.object({
-  allowedRewardRedeemers: z15.preprocess((val) => {
-    if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress(s.trim()));
-    }
-    return val;
-  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
-    description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
-    title: "allowedRewardRedeemers",
-    type: "array"
-  })),
-  allowedRewardEscrowAccountSigners: z15.preprocess((val) => {
-    if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress(s.trim()));
-    }
-    return val;
-  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
-    description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
-    title: "allowedRewardEscrowAccountSigners",
-    type: "array"
-  }))
-});
 
-// src/config/Base.ts
-var BaseConfigZod = z16.object({
-  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
-  dataLake: DataLakeConfigZod.optional().describe("Configuration for data lakes"),
-  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
-  log: LogConfigZod.default(LogConfigZod.parse({})).describe("Configuration for logging"),
-  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe("Configuration for providers"),
-  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe("Configuration for remote services"),
-  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
-  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
-  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
-});
+// src/primitives/block/rate/blockRate.ts
+import { isDefined as isDefined3, isFalsy } from "@xylabs/sdk-js";
+import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
 
-// src/config/Actor.ts
-var ActorConfigZod = BaseConfigZod.extend({
-  name: z17.string(),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry12, {
-    description: "Mnemonic for the Actor wallet",
-    title: "mnemonic",
-    type: "string"
-  }),
-  healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
-    description: "Port for the Producer health checks",
-    title: "producer.healthCheckPort",
-    type: "number"
-  })
+// src/primitives/block/rate/timeHelpers.ts
+import { assertEx as assertEx4, isDefined as isDefined2 } from "@xylabs/sdk-js";
+var rateMultipliers = {
+  millis: 1,
+  seconds: 1e3,
+  minutes: 1e3 * 60,
+  hours: 1e3 * 60 * 60,
+  days: 1e3 * 60 * 60 * 24,
+  weeks: 1e3 * 60 * 60 * 24 * 7
+};
+var timeDurations = (timeInMs) => ({
+  millis: timeInMs,
+  seconds: timeInMs / 1e3,
+  minutes: timeInMs / (1e3 * 60),
+  hours: timeInMs / (1e3 * 60 * 60),
+  days: timeInMs / (1e3 * 60 * 60 * 24),
+  weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
 });
-var isActorConfig = zodIsFactory2(ActorConfigZod);
-var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
-var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
-
-// src/config/Actors.ts
-import z18 from "zod";
-var ActorsConfigZod = z18.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
-
-// src/config/Config.ts
-var ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
-
-// src/block/hydrate/allHashesPresent.ts
-function allHashesPresent(hashes, payloads) {
-  const payloadHashes = new Set(payloads.map((p) => p._hash));
-  return hashes.every((hash) => payloadHashes.has(hash));
-}
-
-// src/block/hydrate/flattenHydratedBlock.ts
-import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
-var flattenHydratedBlock = (hydratedBlock) => {
-  const [blk, blkPayloads] = hydratedBlock;
-  return [...blkPayloads, blk];
+var getTimeConfigInMilliseconds = (timeConfig) => {
+  const assertedTimeConfig = assertEx4(isDefined2(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  let totalMilliseconds = 0;
+  if ("years" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.years * 31536e6;
+    return totalMilliseconds;
+  }
+  if ("months" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.months * 2592e6;
+    return totalMilliseconds;
+  }
+  if ("weeks" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.weeks * 6048e5;
+    return totalMilliseconds;
+  }
+  if ("days" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.days * 864e5;
+    return totalMilliseconds;
+  }
+  if ("hours" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.hours * 36e5;
+    return totalMilliseconds;
+  }
+  if ("minutes" in assertedTimeConfig) {
+    totalMilliseconds += assertedTimeConfig.minutes * 6e4;
+    return totalMilliseconds;
+  }
+  return totalMilliseconds;
 };
 
-// src/block/hydrate/flattenHydratedBlocks.ts
-var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
+// src/primitives/block/rate/blockRate.ts
+var blockRate = (startBlock, endBlock, timeUnit) => {
+  const startingBlock = startBlock[0];
+  const endingBlock = endBlock[0];
+  const heightDifference = endingBlock.block - startingBlock.block;
+  const timeDifference = endingBlock.$epoch - startingBlock.$epoch;
+  if (timeDifference === 0) {
+    throw new Error("Time difference must be greater than 0");
+  }
+  const rate = heightDifference / timeDifference;
+  const timeUnitValue = isDefined3(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined3(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timePerBlock = returnedTimeDifference / heightDifference;
+  return {
+    range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
+    span: heightDifference,
+    rate: isDefined3(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    timeUnit: timeUnitValue,
+    timeDifference: returnedTimeDifference,
+    timePerBlock
+  };
+};
+var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
+  if (endBlockHeight <= startBlockHeight) {
+    console.error("startBlockHeight", startBlockHeight);
+    console.error("endBlockHeight", endBlockHeight);
+    throw new Error("End block height must be greater than start block height");
+  }
+  const startingBlock = await viewer.blockByNumber(startBlockHeight);
+  const endingBlock = await viewer.blockByNumber(endBlockHeight);
+  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
+    throw new Error("Could not retrieve blocks for speed calculation");
+  }
+  return { startingBlock, endingBlock };
+};
+var calculateBlockRate = async (viewer, range, timeUnit) => {
+  const [startBlockHeight, endBlockHeight] = range;
+  const { startingBlock, endingBlock } = await getBlockRateBlocks(
+    viewer,
+    startBlockHeight,
+    endBlockHeight
+  );
+  return blockRate(startingBlock, endingBlock, timeUnit);
+};
 
-// src/block/hydrate/hydrateBlock.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { asAnyPayload } from "@xyo-network/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
-var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
-  assertEx4(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  assertEx4(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
-  assertEx4(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
-  const { chainMap } = context;
-  const [block] = await chainMap.get([hash]);
-  const bw = assertEx4(asBlockBoundWitnessWithStorageMeta(
-    assertEx4(block, () => `block ${hash} not found`)
-  ), () => `hash ${hash} is not a BlockBoundWitness`);
-  if (maxDepth === 0) return [bw, []];
-  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload(p, true));
-  if (minDepth === 1) assertEx4(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
-  if (maxDepth === 1) return [bw, blkPayloads];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
-  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
-  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload(p, true));
-  assertEx4(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload(p, true));
-  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx4(allHashesPresent(
-    [...allPayloadsHashes],
-    allPayloadsFiltered
-  ), () => `Unable to find all payloads for transactions in block ${hash}`);
-  return [bw, allPayloadsFiltered];
+// src/primitives/block/rate/stepRate.ts
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import {
+  asXL1BlockRange as asXL1BlockRange2,
+  isValidStep,
+  StepSizes
+} from "@xyo-network/xl1-protocol-lib";
+var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
+  const end = start + step * count;
+  const range = asXL1BlockRange2([start, end], true);
+  return await calculateBlockRate(viewer, range, timeUnit);
+};
+var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
+  assertEx5(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
+  const step = StepSizes[stepIndex];
+  return await stepRate(viewer, start, step, count, timeUnit);
 };
 
-// src/block/primitives/blockFromBlockNumber.ts
+// src/primitives/block/rate/timeRate.ts
 import {
-  asHash,
+  assertEx as assertEx6,
   isDefined as isDefined4,
-  spanAsync
+  isDefinedNotNull
 } from "@xylabs/sdk-js";
-import { toSafeJsonString } from "@xylabs/sdk-js";
-import {
-  asSignedBlockBoundWitnessWithStorageMeta,
-  SignedBlockBoundWitnessWithHashMetaZod,
-  StepSizes
-} from "@xyo-network/xl1-protocol-lib";
+import { asXL1BlockNumber, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
+var DEFAULT_TOLERANCE_MS = 3e4;
+var DEFAULT_MAX_ATTEMPTS = 10;
+var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
+  assertEx6(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
+  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
+  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
+  assertEx6(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  const blocksPerMillisecondRate = 1 / (12 * 1e3);
+  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
+  const endBlockNumber = await findEndBlockRecursive(
+    viewer,
+    resolvedStartBlock,
+    timeInMilliseconds,
+    initialBlocksInDuration,
+    toleranceMs,
+    maxAttempts
+  );
+  return await calculateBlockRate(
+    viewer,
+    asXL1BlockRange3([endBlockNumber, resolvedStartBlock.block], true),
+    timeUnit
+  );
+};
+var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
+  console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`);
+  assertEx6(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
+  const startBlockEpoch = startBlock.$epoch;
+  const estimatedEndBlockNumber = asXL1BlockNumber(startBlock.block - estimatedBlocksBack, true);
+  if (estimatedEndBlockNumber < 0) {
+    throw new Error("Estimated end block number is less than zero");
+  }
+  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
+  const resolvedEndBlock = assertEx6(
+    isDefined4(endBlock?.[0]) ? endBlock[0] : void 0,
+    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
+  );
+  const endBlockEpoch = resolvedEndBlock.$epoch;
+  if (!Number.isFinite(startBlockEpoch) || !Number.isFinite(endBlockEpoch)) {
+    throw new TypeError("Block has missing or invalid $epoch");
+  }
+  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
+  if (actualTimeDifference === 0) {
+    throw new Error("Start and end blocks have identical timestamps");
+  }
+  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
+  if (timeDelta <= toleranceMs) {
+    return resolvedEndBlock.block;
+  }
+  let adjustedBlocksBack;
+  if (actualTimeDifference < targetTimeMs) {
+    const adjustmentFactor = targetTimeMs / actualTimeDifference;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
+  } else {
+    const adjustmentFactor = actualTimeDifference / targetTimeMs;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
+  }
+  adjustedBlocksBack = Number.isFinite(adjustedBlocksBack) && adjustedBlocksBack >= 1 ? adjustedBlocksBack : 1;
+  return await findEndBlockRecursive(
+    viewer,
+    startBlock,
+    targetTimeMs,
+    adjustedBlocksBack,
+    toleranceMs,
+    attemptsRemaining - 1
+  );
+};
+
+// src/primitives/step/completedStepRewardAddress.ts
+import { toAddress } from "@xylabs/sdk-js";
+import { StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol-lib";
+import { keccak256 } from "ethers";
+function completedStepRewardAddress({ block, step }) {
+  const resolvedStepSize = step < StepSizes2.length ? StepSizes2[step] : step;
+  const addressKey = new TextEncoder().encode(`${block}|${resolvedStepSize}`);
+  return toAddress(keccak256(addressKey).slice(-40), { prefix: false });
+}
 
 // src/ChainContextHelpers.ts
 import {
-  isDefined as isDefined3,
+  isDefined as isDefined6,
   isObject,
   isUndefined as isUndefined2,
   timeBudget
@@ -803,7 +883,7 @@ var LruCacheMap = class {
 };
 
 // src/driver/memory/MemoryMap.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 var MemoryMap = class {
   map;
   constructor() {
@@ -822,7 +902,7 @@ var MemoryMap = class {
     const results = [];
     for (const id of ids) {
       const data = this.map.get(id);
-      if (isDefined2(data)) {
+      if (isDefined5(data)) {
         results.push(data);
       }
     }
@@ -859,7 +939,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4 }
   );
   const { timeBudgetLimit = 0 } = context;
   const cacheResult = await cache.get(key);
-  if (isDefined3(cacheResult)) {
+  if (isDefined6(cacheResult)) {
     return cacheResult;
   }
   const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
@@ -867,317 +947,160 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4 }
   return result;
 }
 
-// src/block/primitives/blockFromBlockNumber.ts
-async function blockFromBlockNumber(context, blockNumber) {
-  return await spanAsync("blockFromBlockNumber", async () => {
-    const cacheKey = `${blockNumber}`;
-    const { chainMap, head } = context;
-    return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
-      const [result] = await chainMap.get([head._hash]);
-      if (!isDefined4(result)) {
-        throw new Error(`Head block not found for hash: ${head._hash}`);
-      }
-      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-        result,
-        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`
-      );
-      if (currentBlock.block < blockNumber) {
-        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
-      }
-      while (currentBlock.block > blockNumber) {
-        let jumpHash = currentBlock.previous;
-        let jumpBlockNumber = currentBlock.block - 1;
-        for (const [step, stepSize] of StepSizes.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize - 1;
-          if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
-            jumpBlockNumber = possibleJumpBlockNumber;
-            jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
-          }
-        }
-        const [newBlock] = await chainMap.get([
-          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
-        ]);
-        if (!isDefined4(newBlock)) {
-          throw new Error(`Block not found for jump hash: ${jumpHash}`);
-        }
-        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-          newBlock,
-          () => {
-            const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
-            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
-          }
-        );
-        if (currentBlock.block === blockNumber) {
-          break;
-        }
-        if (currentBlock.block < blockNumber) {
-          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`);
-        }
-      }
-      return currentBlock;
-    });
-  }, { ...context, timeBudgetLimit: 500 });
-}
-
-// src/block/primitives/validateTransactionOpcodes.ts
-import {
-  assertEx as assertEx5,
-  isHash,
-  toSafeJsonString as toSafeJsonString2
-} from "@xylabs/sdk-js";
-import {
-  PayloadBuilder
-} from "@xyo-network/sdk-js";
-import { isExecutable } from "@xyo-network/xl1-protocol-lib";
-async function validateTransactionsOpcodes(txs) {
-  const txElevatedPayloads = [];
-  for (const [txBw, txPayloads] of txs) {
-    if (isExecutable(txBw)) {
-      const operations = txBw.script.map((op) => op.split("|"));
-      for (const [opCode, ...args] of operations) {
-        switch (opCode) {
-          case "elevate": {
-            const [hash, ...rest] = args;
-            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
-            assertEx5(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
-            if (isHash(hash)) {
-              assertEx5(
-                txBw.payload_hashes.includes(hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
-              );
-              const txPayload = assertEx5(
-                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
-              );
-              txElevatedPayloads.push(txPayload);
-            } else {
-              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
-            }
-            break;
-          }
-          default: {
-            throw new Error(`Invalid opCode ${opCode}`);
-          }
-        }
-      }
-    }
-  }
-  return txElevatedPayloads;
+// src/block/hydrate/allHashesPresent.ts
+function allHashesPresent(hashes, payloads) {
+  const payloadHashes = new Set(payloads.map((p) => p._hash));
+  return hashes.every((hash) => payloadHashes.has(hash));
 }
 
-// src/simple/block/SimpleBlockViewer.ts
-import {
-  assertEx as assertEx10,
-  exists,
-  isUndefined as isUndefined4
-} from "@xylabs/sdk-js";
-import {
-  asSignedHydratedBlockWithHashMeta,
-  asSignedHydratedBlockWithStorageMeta,
-  asXL1BlockNumber as asXL1BlockNumber2,
-  BlockViewerMoniker,
-  DataLakeViewerMoniker,
-  FinalizationViewerMoniker
-} from "@xyo-network/xl1-protocol-lib";
-
-// src/primitives/block/rate/blockRate.ts
-import { isDefined as isDefined6, isFalsy } from "@xylabs/sdk-js";
-import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
-
-// src/primitives/block/rate/timeHelpers.ts
-import { assertEx as assertEx6, isDefined as isDefined5 } from "@xylabs/sdk-js";
-var rateMultipliers = {
-  millis: 1,
-  seconds: 1e3,
-  minutes: 1e3 * 60,
-  hours: 1e3 * 60 * 60,
-  days: 1e3 * 60 * 60 * 24,
-  weeks: 1e3 * 60 * 60 * 24 * 7
-};
-var timeDurations = (timeInMs) => ({
-  millis: timeInMs,
-  seconds: timeInMs / 1e3,
-  minutes: timeInMs / (1e3 * 60),
-  hours: timeInMs / (1e3 * 60 * 60),
-  days: timeInMs / (1e3 * 60 * 60 * 24),
-  weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
-});
-var getTimeConfigInMilliseconds = (timeConfig) => {
-  const assertedTimeConfig = assertEx6(isDefined5(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
-  let totalMilliseconds = 0;
-  if ("years" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.years * 31536e6;
-    return totalMilliseconds;
-  }
-  if ("months" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.months * 2592e6;
-    return totalMilliseconds;
-  }
-  if ("weeks" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.weeks * 6048e5;
-    return totalMilliseconds;
-  }
-  if ("days" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.days * 864e5;
-    return totalMilliseconds;
-  }
-  if ("hours" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.hours * 36e5;
-    return totalMilliseconds;
-  }
-  if ("minutes" in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.minutes * 6e4;
-    return totalMilliseconds;
-  }
-  return totalMilliseconds;
+// src/block/hydrate/flattenHydratedBlock.ts
+import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
+var flattenHydratedBlock = (hydratedBlock) => {
+  const [blk, blkPayloads] = hydratedBlock;
+  return [...blkPayloads, blk];
 };
 
-// src/primitives/block/rate/blockRate.ts
-var blockRate = (startBlock, endBlock, timeUnit) => {
-  const startingBlock = startBlock[0];
-  const endingBlock = endBlock[0];
-  const heightDifference = endingBlock.block - startingBlock.block;
-  const timeDifference = endingBlock.$epoch - startingBlock.$epoch;
-  if (timeDifference === 0) {
-    throw new Error("Time difference must be greater than 0");
-  }
-  const rate = heightDifference / timeDifference;
-  const timeUnitValue = isDefined6(timeUnit) ? timeUnit : "millis";
-  const returnedTimeDifference = isDefined6(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
-  const timePerBlock = returnedTimeDifference / heightDifference;
-  return {
-    range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
-    span: heightDifference,
-    rate: isDefined6(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
-    timeUnit: timeUnitValue,
-    timeDifference: returnedTimeDifference,
-    timePerBlock
-  };
-};
-var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
-  if (endBlockHeight <= startBlockHeight) {
-    console.error("startBlockHeight", startBlockHeight);
-    console.error("endBlockHeight", endBlockHeight);
-    throw new Error("End block height must be greater than start block height");
-  }
-  const startingBlock = await viewer.blockByNumber(startBlockHeight);
-  const endingBlock = await viewer.blockByNumber(endBlockHeight);
-  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
-    throw new Error("Could not retrieve blocks for speed calculation");
-  }
-  return { startingBlock, endingBlock };
-};
-var calculateBlockRate = async (viewer, range, timeUnit) => {
-  const [startBlockHeight, endBlockHeight] = range;
-  const { startingBlock, endingBlock } = await getBlockRateBlocks(
-    viewer,
-    startBlockHeight,
-    endBlockHeight
-  );
-  return blockRate(startingBlock, endingBlock, timeUnit);
-};
+// src/block/hydrate/flattenHydratedBlocks.ts
+var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
 
-// src/primitives/block/rate/stepRate.ts
+// src/block/hydrate/hydrateBlock.ts
 import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { asAnyPayload } from "@xyo-network/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
+  assertEx7(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  assertEx7(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
+  assertEx7(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
+  const { chainMap } = context;
+  const [block] = await chainMap.get([hash]);
+  const bw = assertEx7(asBlockBoundWitnessWithStorageMeta(
+    assertEx7(block, () => `block ${hash} not found`)
+  ), () => `hash ${hash} is not a BlockBoundWitness`);
+  if (maxDepth === 0) return [bw, []];
+  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload(p, true));
+  if (minDepth === 1) assertEx7(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
+  if (maxDepth === 1) return [bw, blkPayloads];
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
+  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
+  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload(p, true));
+  assertEx7(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
+  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
+  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload(p, true));
+  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  if (maxDepth === 2) assertEx7(allHashesPresent(
+    [...allPayloadsHashes],
+    allPayloadsFiltered
+  ), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [bw, allPayloadsFiltered];
+};
+
+// src/block/primitives/blockFromBlockNumber.ts
 import {
-  asXL1BlockRange as asXL1BlockRange2,
-  isValidStep,
-  StepSizes as StepSizes2
+  asHash,
+  isDefined as isDefined7,
+  spanAsync
+} from "@xylabs/sdk-js";
+import { toSafeJsonString } from "@xylabs/sdk-js";
+import {
+  asSignedBlockBoundWitnessWithStorageMeta,
+  SignedBlockBoundWitnessWithHashMetaZod,
+  StepSizes as StepSizes3
 } from "@xyo-network/xl1-protocol-lib";
-var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
-  const end = start + step * count;
-  const range = asXL1BlockRange2([start, end], true);
-  return await calculateBlockRate(viewer, range, timeUnit);
-};
-var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
-  assertEx7(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
-  const step = StepSizes2[stepIndex];
-  return await stepRate(viewer, start, step, count, timeUnit);
-};
+async function blockFromBlockNumber(context, blockNumber) {
+  return await spanAsync("blockFromBlockNumber", async () => {
+    const cacheKey = `${blockNumber}`;
+    const { chainMap, head } = context;
+    return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
+      const [result] = await chainMap.get([head._hash]);
+      if (!isDefined7(result)) {
+        throw new Error(`Head block not found for hash: ${head._hash}`);
+      }
+      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+        result,
+        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`
+      );
+      if (currentBlock.block < blockNumber) {
+        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
+      }
+      while (currentBlock.block > blockNumber) {
+        let jumpHash = currentBlock.previous;
+        let jumpBlockNumber = currentBlock.block - 1;
+        for (const [step, stepSize] of StepSizes3.entries()) {
+          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize - 1;
+          if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
+            jumpBlockNumber = possibleJumpBlockNumber;
+            jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
+          }
+        }
+        const [newBlock] = await chainMap.get([
+          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
+        ]);
+        if (!isDefined7(newBlock)) {
+          throw new Error(`Block not found for jump hash: ${jumpHash}`);
+        }
+        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+          newBlock,
+          () => {
+            const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
+            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
+          }
+        );
+        if (currentBlock.block === blockNumber) {
+          break;
+        }
+        if (currentBlock.block < blockNumber) {
+          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`);
+        }
+      }
+      return currentBlock;
+    });
+  }, { ...context, timeBudgetLimit: 500 });
+}
 
-// src/primitives/block/rate/timeRate.ts
+// src/block/primitives/validateTransactionOpcodes.ts
 import {
   assertEx as assertEx8,
-  isDefined as isDefined7,
-  isDefinedNotNull
+  isHash,
+  toSafeJsonString as toSafeJsonString2
 } from "@xylabs/sdk-js";
-import { asXL1BlockNumber, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
-var DEFAULT_TOLERANCE_MS = 3e4;
-var DEFAULT_MAX_ATTEMPTS = 10;
-var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
-  assertEx8(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
-  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
-  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
-  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
-  assertEx8(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
-  const blocksPerMillisecondRate = 1 / (12 * 1e3);
-  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
-  const endBlockNumber = await findEndBlockRecursive(
-    viewer,
-    resolvedStartBlock,
-    timeInMilliseconds,
-    initialBlocksInDuration,
-    toleranceMs,
-    maxAttempts
-  );
-  return await calculateBlockRate(
-    viewer,
-    asXL1BlockRange3([endBlockNumber, resolvedStartBlock.block], true),
-    timeUnit
-  );
-};
-var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
-  console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`);
-  assertEx8(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
-  const startBlockEpoch = startBlock.$epoch;
-  const estimatedEndBlockNumber = asXL1BlockNumber(startBlock.block - estimatedBlocksBack, true);
-  if (estimatedEndBlockNumber < 0) {
-    throw new Error("Estimated end block number is less than zero");
-  }
-  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
-  const resolvedEndBlock = assertEx8(
-    isDefined7(endBlock?.[0]) ? endBlock[0] : void 0,
-    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
-  );
-  const endBlockEpoch = resolvedEndBlock.$epoch;
-  if (!Number.isFinite(startBlockEpoch) || !Number.isFinite(endBlockEpoch)) {
-    throw new TypeError("Block has missing or invalid $epoch");
-  }
-  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
-  if (actualTimeDifference === 0) {
-    throw new Error("Start and end blocks have identical timestamps");
-  }
-  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
-  if (timeDelta <= toleranceMs) {
-    return resolvedEndBlock.block;
-  }
-  let adjustedBlocksBack;
-  if (actualTimeDifference < targetTimeMs) {
-    const adjustmentFactor = targetTimeMs / actualTimeDifference;
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
-  } else {
-    const adjustmentFactor = actualTimeDifference / targetTimeMs;
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
+import {
+  PayloadBuilder
+} from "@xyo-network/sdk-js";
+import { isExecutable } from "@xyo-network/xl1-protocol-lib";
+async function validateTransactionsOpcodes(txs) {
+  const txElevatedPayloads = [];
+  for (const [txBw, txPayloads] of txs) {
+    if (isExecutable(txBw)) {
+      const operations = txBw.script.map((op) => op.split("|"));
+      for (const [opCode, ...args] of operations) {
+        switch (opCode) {
+          case "elevate": {
+            const [hash, ...rest] = args;
+            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
+            assertEx8(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
+            if (isHash(hash)) {
+              assertEx8(
+                txBw.payload_hashes.includes(hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
+              );
+              const txPayload = assertEx8(
+                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
+              );
+              txElevatedPayloads.push(txPayload);
+            } else {
+              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
+            }
+            break;
+          }
+          default: {
+            throw new Error(`Invalid opCode ${opCode}`);
+          }
+        }
+      }
+    }
   }
-  adjustedBlocksBack = Number.isFinite(adjustedBlocksBack) && adjustedBlocksBack >= 1 ? adjustedBlocksBack : 1;
-  return await findEndBlockRecursive(
-    viewer,
-    startBlock,
-    targetTimeMs,
-    adjustedBlocksBack,
-    toleranceMs,
-    attemptsRemaining - 1
-  );
-};
-
-// src/primitives/step/completedStepRewardAddress.ts
-import { toAddress } from "@xylabs/sdk-js";
-import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
-import { keccak256 } from "ethers";
-function completedStepRewardAddress({ block, step }) {
-  const resolvedStepSize = step < StepSizes3.length ? StepSizes3[step] : step;
-  const addressKey = new TextEncoder().encode(`${block}|${resolvedStepSize}`);
-  return toAddress(keccak256(addressKey).slice(-40), { prefix: false });
+  return txElevatedPayloads;
 }
 
 // src/primitives/datalake/addDataLakePayloadsToPayloads.ts
@@ -1249,6 +1172,99 @@ async function hydratedBlockByNumber(context, blockNumber) {
   }, { ...context, timeBudgetLimit: 500 });
 }
 
+// src/primitives/uncle/findBestUncle.ts
+var DEFAULT_MIN_CANDIDATES = 2;
+var DEFAULT_BACKOFF_MS = 12e4;
+
+// src/config/Validation.ts
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
+    description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
+    title: "allowedRewardRedeemers",
+    type: "array"
+  })),
+  allowedRewardEscrowAccountSigners: z15.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
+    description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
+    title: "allowedRewardEscrowAccountSigners",
+    type: "array"
+  })),
+  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
+    default: DEFAULT_MIN_CANDIDATES,
+    description: "Minimum number of uncle candidates before selecting the best uncle",
+    title: "validation.minCandidates",
+    type: "number"
+  }),
+  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
+    default: DEFAULT_BACKOFF_MS,
+    description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
+    title: "validation.backoffMs",
+    type: "number"
+  })
+});
+
+// src/config/Base.ts
+var BaseConfigZod = z16.object({
+  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
+  dataLake: DataLakeConfigZod.optional().describe("Configuration for data lakes"),
+  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
+  log: LogConfigZod.default(LogConfigZod.parse({})).describe("Configuration for logging"),
+  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe("Configuration for providers"),
+  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe("Configuration for remote services"),
+  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
+  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
+  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
+});
+
+// src/config/Actor.ts
+var ActorConfigZod = BaseConfigZod.extend({
+  name: z17.string(),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry12, {
+    description: "Mnemonic for the Actor wallet",
+    title: "mnemonic",
+    type: "string"
+  }),
+  healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
+    description: "Port for the Producer health checks",
+    title: "producer.healthCheckPort",
+    type: "number"
+  })
+});
+var isActorConfig = zodIsFactory2(ActorConfigZod);
+var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
+var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
+
+// src/config/Actors.ts
+import z18 from "zod";
+var ActorsConfigZod = z18.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
+
+// src/config/Config.ts
+var ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
+
+// src/simple/block/SimpleBlockViewer.ts
+import {
+  assertEx as assertEx10,
+  exists,
+  isUndefined as isUndefined4
+} from "@xylabs/sdk-js";
+import {
+  asSignedHydratedBlockWithHashMeta,
+  asSignedHydratedBlockWithStorageMeta,
+  asXL1BlockNumber as asXL1BlockNumber2,
+  BlockViewerMoniker,
+  DataLakeViewerMoniker,
+  FinalizationViewerMoniker
+} from "@xyo-network/xl1-protocol-lib";
+
 // src/utils/HydratedCache.ts
 import { LRUCache as LRUCache2 } from "lru-cache";
 var HydratedCache = class {