@xyo-network/xl1-protocol-sdk 1.17.7 → 1.18.0

package/dist/neutral/index.mjs

@@ -118,12 +118,12 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 }, "tryHydrateBlock");
 
 // src/block/primitives/blockFromBlockNumber.ts
-import { asHash as asHash3, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { asHash as asHash3, isDefined as isDefined10 } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
-import { asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol";
+import { asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
 
 // src/model/ChainContext/ChainContext.ts
-import { isDefined as isDefined4, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined8, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 
 // src/driver/cache/LruCacheMap.ts
 import { LRUCache } from "lru-cache";
@@ -211,46 +211,137 @@ var MemoryMap = class {
   }
 };
 
-// src/primitives/readPayloadMapFromStore.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-function readPayloadMapFromStore(store) {
-  if (isReadArchivist(store)) {
-    return {
-      get: /* @__PURE__ */ __name(async (hash) => {
-        return (await store.get([
-          hash
-        ]))[0];
-      }, "get"),
-      getMany: /* @__PURE__ */ __name(async (hashes) => {
-        return await store.get(hashes);
-      }, "getMany"),
-      has: /* @__PURE__ */ __name(async (hash) => {
-        return isDefined2((await store.get([
-          hash
-        ]))[0]);
-      }, "has")
-    };
+// src/primitives/block/range/blockRangeSteps.ts
+import { asXL1BlockNumber, StepSizes } from "@xyo-network/xl1-protocol";
+function blockRangeSteps(range, steps) {
+  const result = [];
+  for (const step of steps) {
+    const stepSize2 = StepSizes[step];
+    const startOfFirstStepCandidate = range[0] - range[0] % stepSize2 + stepSize2;
+    const startOfFirstStep = asXL1BlockNumber(startOfFirstStepCandidate, {
+      name: "blockRangeSteps"
+    });
+    for (let block = startOfFirstStep; block <= range[1]; block = asXL1BlockNumber(block + stepSize2, {
+      name: "blockRangeSteps"
+    })) {
+      result.push({
+        step,
+        block
+      });
+    }
   }
-  return store;
+  return result;
 }
-__name(readPayloadMapFromStore, "readPayloadMapFromStore");
+__name(blockRangeSteps, "blockRangeSteps");
+
+// src/primitives/chain/getWindowedChain.ts
+async function getWindowedChain(blockViewer, maxWindowSize, previousChain = []) {
+  const newBlocks = [];
+  let currentBlock = await blockViewer.currentBlock();
+  console.log("[getWindowedChain] Current Block:", currentBlock?.[0]._hash);
+  const head = currentBlock;
+  while (currentBlock !== null && currentBlock[0].block >= head[0].block) {
+    newBlocks.unshift(currentBlock);
+    const previousBlockHash = currentBlock[0].previous;
+    currentBlock = previousBlockHash === null ? null : await blockViewer.blockByHash(previousBlockHash);
+  }
+  const newChain = [
+    ...previousChain,
+    ...newBlocks
+  ].slice(-maxWindowSize);
+  while (newChain.length > 0 && newChain.length < maxWindowSize && newChain[0][0].previous !== null) {
+    const block = await blockViewer.blockByHash(newChain[0][0].previous);
+    if (block === null) break;
+    newChain.unshift(block);
+  }
+  return newChain;
+}
+__name(getWindowedChain, "getWindowedChain");
+
+// src/primitives/chain/step/chainStepRewardAddress.ts
+import { assertEx as assertEx7, exists, toAddress as toAddress4 } from "@xylabs/sdk-js";
+import { asTransfer, isTransfer, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
+
+// src/primitives/payload/mergeTransfers.ts
+import { hexToBigInt, toAddress } from "@xylabs/sdk-js";
+function mergeTransfers(transfers) {
+  const result = {};
+  for (const transfer of transfers) {
+    result[transfer.from] = result[transfer.from] ?? {};
+    for (const [to, value] of Object.entries(transfer.transfers)) {
+      const typedTo = toAddress(to);
+      result[transfer.from][typedTo] = (result[transfer.from][typedTo] ?? 0n) + hexToBigInt(value);
+    }
+  }
+  return result;
+}
+__name(mergeTransfers, "mergeTransfers");
 
-// src/primitives/rewardFromBlockNumber.ts
-import { toFixedPoint } from "@xylabs/sdk-js";
-import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-var rewardFromBlockNumber = /* @__PURE__ */ __name((places = 18) => {
-  return (blockNumber, startingReward = asAttoXL1(toFixedPoint(500n, places)), blocksPerStep = 1e6, stepFactorNumerator = 95n, stepFactorDenominator = 100n, minBlockReward = asAttoXL1(toFixedPoint(10n, places)), creatorReward = asAttoXL1(toFixedPoint(20000000000n, places))) => {
-    if (blockNumber === 0) {
-      return creatorReward;
+// src/primitives/step/completedStepRewardAddress.ts
+import { toAddress as toAddress2 } from "@xylabs/sdk-js";
+import { StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
+import { keccak256 } from "ethers";
+function completedStepRewardAddress({ block, step }) {
+  const resolvedStepSize = step < StepSizes2.length ? StepSizes2[step] : step;
+  const addressKey = new TextEncoder().encode(`${block}|${resolvedStepSize}`);
+  return toAddress2(keccak256(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(completedStepRewardAddress, "completedStepRewardAddress");
+
+// src/primitives/step/derivedReceiveAddress.ts
+import { toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { keccak256 as keccak2562 } from "ethers";
+function derivedReceiveAddress(address, scope) {
+  const addressKey = new TextEncoder().encode(isDefined2(scope) ? `${scope}|${address}` : address);
+  return toAddress3(keccak2562(addressKey).slice(-40), {
+    prefix: false
+  });
+}
+__name(derivedReceiveAddress, "derivedReceiveAddress");
+
+// src/primitives/step/stepBlockRange.ts
+import { asXL1BlockRange, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
+function stepBlockRange({ block, step }) {
+  const stepSize2 = StepSizes3[step];
+  const start = block - stepSize2;
+  return asXL1BlockRange([
+    start,
+    start + stepSize2 - 1
+  ], {
+    name: "stepBlockRange"
+  });
+}
+__name(stepBlockRange, "stepBlockRange");
+
+// src/primitives/step/stepTransferIndex.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol";
+function stepTransferIndex(block, step) {
+  let rewardTransferCount = 0;
+  let rewardTransferIndex = -1;
+  for (let i = 3; i < StepSizes4.length; i++) {
+    const stepSize2 = StepSizes4[i];
+    if (block % stepSize2 === 0) {
+      if (stepSize2 === StepSizes4[step]) {
+        rewardTransferIndex = rewardTransferCount;
+      }
+      rewardTransferCount++;
     }
-    const step = Math.floor((blockNumber + blocksPerStep) / blocksPerStep);
-    const stepExp = BigInt(step - 1);
-    const poweredNumerator = stepExp > 0 ? stepFactorNumerator ** stepExp : 1n;
-    const poweredDenominator = stepExp > 0 ? stepFactorDenominator ** stepExp : 1n;
-    let reward = startingReward * poweredNumerator / poweredDenominator;
-    return asAttoXL1(reward < minBlockReward ? minBlockReward : reward);
-  };
-}, "rewardFromBlockNumber");
+  }
+  assertEx4(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
+  return [
+    rewardTransferIndex,
+    rewardTransferCount
+  ];
+}
+__name(stepTransferIndex, "stepTransferIndex");
+
+// src/primitives/chain/step/stepRewardBlock.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
 
 // src/primitives/state/findMostRecentBlock.ts
 import { isSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
@@ -282,80 +373,534 @@ var findMostRecentBlock = /* @__PURE__ */ __name(async (chainArchivist, nextOpti
 }, "findMostRecentBlock");
 
 // src/primitives/state/hydratedBlockByNumber.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 async function hydratedBlockByNumber(context, blockNumber) {
   if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`);
   if (blockNumber > Number.MAX_SAFE_INTEGER) throw new Error(`Block number ${blockNumber} is greater than the maximum safe integer`);
   if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`);
   const cacheKey = `${blockNumber}`;
   return await withContextCacheResponse(context, "hydratedBlockByNumber", cacheKey, async () => {
-    const block = assertEx4(await blockFromBlockNumber(context, blockNumber), () => `Could not find block for block number ${blockNumber}`);
+    const block = assertEx5(await blockFromBlockNumber(context, blockNumber), () => `Could not find block for block number ${blockNumber}`);
     return await hydrateBlock(context.store, block._hash);
   });
 }
 __name(hydratedBlockByNumber, "hydratedBlockByNumber");
 
-// src/primitives/step/completedStepRewardAddress.ts
-import { toAddress } from "@xylabs/sdk-js";
-import { StepSizes } from "@xyo-network/xl1-protocol";
-import { keccak256 } from "ethers";
-function completedStepRewardAddress({ block, step }) {
-  const resolvedStepSize = step < StepSizes.length ? StepSizes[step] : step;
-  const addressKey = new TextEncoder().encode(`${block}|${resolvedStepSize}`);
-  return toAddress(keccak256(addressKey).slice(-40), {
-    prefix: false
+// src/primitives/chain/step/stepRewardBlock.ts
+async function stepRewardBlock(context, { block, step }) {
+  assertEx6(block % StepSizes5[step] === 0, () => `Block must be the first block of the step [${StepSizes5[step]}], got ${block}`);
+  return assertEx6(await hydratedBlockByNumber(context, block), () => `Could not find block for block number ${block}`);
+}
+__name(stepRewardBlock, "stepRewardBlock");
+
+// src/primitives/chain/step/chainStepRewardAddress.ts
+async function chainStepRewardAddress(context, { block, step }) {
+  const hydratedBlock = await stepRewardBlock(context, {
+    block,
+    step
   });
+  const [transferIndex, transferCount] = stepTransferIndex(block, step);
+  const [blockBw, payloads] = hydratedBlock;
+  const transfersFromPool = payloads.filter(isTransfer).map((p) => asTransfer(p)).filter(exists).filter((t) => t.from === XYO_STEP_REWARD_ADDRESS);
+  const fromEntries = Object.entries(mergeTransfers(transfersFromPool)[XYO_STEP_REWARD_ADDRESS]);
+  const sortedTransferAmounts = fromEntries.toSorted(([, a], [, b]) => a > b ? -1 : a < b ? 1 : 0);
+  assertEx7(sortedTransferAmounts.length === transferCount, () => `Step Transfers mismatch ${block} (${blockBw._hash}) [${sortedTransferAmounts.length} - ${transferCount}]`);
+  return toAddress4(sortedTransferAmounts[transferIndex][0]);
 }
-__name(completedStepRewardAddress, "completedStepRewardAddress");
+__name(chainStepRewardAddress, "chainStepRewardAddress");
 
-// src/primitives/step/derivedReceiveAddress.ts
-import { toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { keccak256 as keccak2562 } from "ethers";
-function derivedReceiveAddress(address, scope) {
-  const addressKey = new TextEncoder().encode(isDefined3(scope) ? `${scope}|${address}` : address);
-  return toAddress2(keccak2562(addressKey).slice(-40), {
-    prefix: false
+// src/primitives/chain/step/stepRewardTotal.ts
+import { assertEx as assertEx8, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { asAttoXL1, asXL1BlockRange as asXL1BlockRange2, isTransfer as isTransfer5, XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2 } from "@xyo-network/xl1-protocol";
+
+// src/payloads/AddressPairPayload.ts
+import { AsObjectFactory } from "@xylabs/sdk-js";
+import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var AddressPairSchema = "network.xyo.address.pair";
+var isAddressPairPayload = isPayloadOfSchemaType(AddressPairSchema);
+var asAddressPairPayload = AsObjectFactory.create(isAddressPairPayload);
+var asOptionalAddressPairPayload = AsObjectFactory.createOptional(isAddressPairPayload);
+
+// src/payloads/netBalancesForPayloads.ts
+import { hexToBigInt as hexToBigInt2, toAddress as toAddress5 } from "@xylabs/sdk-js";
+import { span } from "@xylabs/sdk-js";
+import { isTransfer as isTransfer2 } from "@xyo-network/xl1-protocol";
+var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
+  return span("netBalancesForPayloads", () => {
+    const balances = {};
+    for (const payload of payloads) {
+      if (isTransfer2(payload)) {
+        const { from } = payload;
+        for (let [address, amount] of Object.entries(payload.transfers)) {
+          balances[toAddress5(address)] = (balances[toAddress5(address)] ?? 0n) + hexToBigInt2(amount);
+          balances[toAddress5(from)] = (balances[toAddress5(from)] ?? 0n) - hexToBigInt2(amount);
+        }
+      }
+    }
+    return balances;
+  });
+}, "netBalancesForPayloads");
+
+// src/payloads/netSchemasForPayloads.ts
+import { hexToBigInt as hexToBigInt3, toAddress as toAddress6 } from "@xylabs/sdk-js";
+import { span as span2 } from "@xylabs/sdk-js";
+import { isTransfer as isTransfer3 } from "@xyo-network/xl1-protocol";
+var netSchemasForPayloads = /* @__PURE__ */ __name((payloads) => {
+  return span2("netSchemasForPayloads", () => {
+    const balances = {};
+    for (const payload of payloads) {
+      if (isTransfer3(payload)) {
+        const { from } = payload;
+        for (let [address, amount] of Object.entries(payload.transfers)) {
+          balances[toAddress6(address)] = (balances[toAddress6(address)] ?? 0n) + hexToBigInt3(amount);
+          balances[toAddress6(from)] = (balances[toAddress6(from)] ?? 0n) - hexToBigInt3(amount);
+        }
+      }
+    }
+    return balances;
+  });
+}, "netSchemasForPayloads");
+
+// src/payloads/netTransfersForPayloads.ts
+import { hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+import { span as span3 } from "@xylabs/sdk-js";
+import { isTransfer as isTransfer4 } from "@xyo-network/xl1-protocol";
+function netTransfersForPayloads(payloads) {
+  return span3("netTransfersForPayloads", () => {
+    const transfers = {};
+    for (const payload of payloads) {
+      if (isTransfer4(payload)) {
+        const { from } = payload;
+        transfers[from] = transfers[from] ?? {};
+        for (let [to, amount] of Object.entries(payload.transfers)) {
+          transfers[to] = transfers[to] ?? {};
+          transfers[to][from] = (transfers[to][from] ?? 0n) + hexToBigInt4(amount);
+          transfers[from][to] = (transfers[from][to] ?? 0n) - hexToBigInt4(amount);
+        }
+      }
+    }
+    return transfers;
   });
 }
-__name(derivedReceiveAddress, "derivedReceiveAddress");
+__name(netTransfersForPayloads, "netTransfersForPayloads");
 
-// src/primitives/step/stepBlockRange.ts
-import { asXL1BlockRange, StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
-function stepBlockRange({ block, step }) {
-  const stepSize2 = StepSizes2[step];
-  const start = block - stepSize2;
-  return asXL1BlockRange([
-    start,
-    start + stepSize2 - 1
+// src/primitives/chain/step/stepRewardTotal.ts
+function stepInRange(step, range) {
+  const stepRange = stepBlockRange(step);
+  return stepRange[0] >= range[0] && stepRange[1] <= range[1];
+}
+__name(stepInRange, "stepInRange");
+async function stepRewardTotal(context, { block, step }, multipliers) {
+  const cacheKey = `${block}|${step}|${isDefined3(multipliers)}`;
+  return await withContextCacheResponse(context, "stepRewardTotal", cacheKey, async () => {
+    const [blockBw, payloads] = await stepRewardBlock(context, {
+      block,
+      step
+    });
+    assertEx8(blockBw.block === block, () => `Block Mismatch: expected ${block}, got ${blockBw.block}`);
+    const [transferIndex] = stepTransferIndex(block, step);
+    const stepTransfer = assertEx8(payloads.find((p) => isTransfer5(p) && p.from === XYO_STEP_REWARD_ADDRESS2), () => `No step transfer found for step ${step} at block ${block} (${blockBw._hash})`);
+    const rewards = assertEx8(netTransfersForPayloads([
+      stepTransfer
+    ])[XYO_STEP_REWARD_ADDRESS2], () => `No rewards found for step reward address ${XYO_STEP_REWARD_ADDRESS2} at block ${block} (${blockBw._hash})`);
+    const sortedTransfers = Object.entries(rewards).toSorted(([, a], [, b]) => a > b ? -1 : a < b ? 1 : 0);
+    let result = asAttoXL1(sortedTransfers[transferIndex][1] * -1n);
+    for (const [rangeKey, [numerator, denominator]] of Object.entries(multipliers)) {
+      const rangeParts = rangeKey.split("|").map(Number);
+      const range = asXL1BlockRange2([
+        rangeParts[0],
+        rangeParts[1]
+      ], {
+        name: "stepRewardTotal"
+      });
+      if (stepInRange({
+        block,
+        step
+      }, range)) {
+        result = asAttoXL1(result + result * numerator / denominator);
+      }
+    }
+    return result;
+  });
+}
+__name(stepRewardTotal, "stepRewardTotal");
+
+// src/primitives/chain/step/stepsRewardTotal.ts
+import { asAttoXL1 as asAttoXL12, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol";
+
+// src/constants.ts
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH = 1760572800;
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK = 107496;
+
+// src/primitives/chain/step/stepsRewardTotal.ts
+async function stepsRewardTotalGenesisPeriod(context, multipliers, stepSizes) {
+  const range = asXL1BlockRange3([
+    0,
+    XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK
   ], {
-    name: "stepBlockRange"
+    name: "stepsRewardTotalGenesisPeriod"
   });
+  return await stepsRewardTotalRange(context, range, stepSizes, multipliers);
 }
-__name(stepBlockRange, "stepBlockRange");
+__name(stepsRewardTotalGenesisPeriod, "stepsRewardTotalGenesisPeriod");
+async function stepsRewardTotalRange(context, range, stepSizes = [
+  3,
+  4,
+  5,
+  6
+], multipliers) {
+  const steps = blockRangeSteps(range, stepSizes);
+  return await stepsRewardTotal(context, steps, multipliers);
+}
+__name(stepsRewardTotalRange, "stepsRewardTotalRange");
+async function stepsRewardTotal(context, steps, multipliers) {
+  let totalRewards = 0n;
+  for (const step of steps) {
+    const stepTotal = await stepRewardTotal(context, step, multipliers);
+    totalRewards += stepTotal;
+  }
+  return asAttoXL12(totalRewards);
+}
+__name(stepsRewardTotal, "stepsRewardTotal");
+
+// src/primitives/chain/time/externalBlockNumberFromXL1BlockNumber.ts
+import { assertEx as assertEx9, isArray } from "@xylabs/sdk-js";
+import { asBlockNumber, asTimePayload, isTimePayload } from "@xyo-network/xl1-protocol";
+var functionName = "externalBlockNumberFromXL1BlockNumber";
+async function externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockNumber, externalTimeName, externalGenesisTime, timeBudgetMs = 2e3) {
+  const cacheKey = `${xl1BlockNumber}-${externalTimeName}-${externalGenesisTime ?? "default"}`;
+  return await withContextCacheResponse(context, functionName, cacheKey, async () => {
+    const [, payloads = []] = await blockViewer.blockByNumber(xl1BlockNumber) ?? [];
+    assertEx9(isArray(payloads));
+    const timePayload = asTimePayload(payloads.find(isTimePayload));
+    return asBlockNumber(timePayload?.[externalTimeName] ?? externalGenesisTime ?? 23372716, {
+      name: functionName
+    });
+  }, {
+    timeBudgetMs
+  });
+}
+__name(externalBlockNumberFromXL1BlockNumber, "externalBlockNumberFromXL1BlockNumber");
 
-// src/primitives/step/stepTransferIndex.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
-import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
-function stepTransferIndex(block, step) {
-  let rewardTransferCount = 0;
-  let rewardTransferIndex = -1;
-  for (let i = 3; i < StepSizes3.length; i++) {
-    const stepSize2 = StepSizes3[i];
-    if (block % stepSize2 === 0) {
-      if (stepSize2 === StepSizes3[step]) {
-        rewardTransferIndex = rewardTransferCount;
+// src/primitives/chain/time/externalBlockRangeFromXL1BlockRange.ts
+async function externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange, externalTimeName = "ethereum") {
+  const start = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[0], externalTimeName);
+  const end = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[1], externalTimeName);
+  return [
+    start,
+    end
+  ];
+}
+__name(externalBlockRangeFromXL1BlockRange, "externalBlockRangeFromXL1BlockRange");
+
+// src/primitives/chain/time/externalBlockRangeFromStep.ts
+async function externalBlockRangeFromStep(context, blockViewer, stepIdentity) {
+  const cacheKey = toStepIdentityString(stepIdentity);
+  return await withContextCacheResponse(context, "externalBlockRangeFromStep", cacheKey, async () => {
+    const xl1BlockRange = stepBlockRange(stepIdentity);
+    return await externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange);
+  }, {
+    timeBudgetMs: 1e3
+  });
+}
+__name(externalBlockRangeFromStep, "externalBlockRangeFromStep");
+
+// src/primitives/mapToMapType.ts
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+function mapToMapType(map) {
+  return {
+    get: /* @__PURE__ */ __name((key) => map.get(key), "get"),
+    has: /* @__PURE__ */ __name((key) => map.has(key), "has"),
+    set: /* @__PURE__ */ __name((key, value) => {
+      map.set(key, value);
+    }, "set"),
+    setMany: /* @__PURE__ */ __name((entries) => {
+      for (const [key, value] of entries) {
+        map.set(key, value);
+      }
+    }, "setMany"),
+    delete: /* @__PURE__ */ __name((key) => map.delete(key), "delete"),
+    clear: /* @__PURE__ */ __name(() => map.clear(), "clear"),
+    getMany: /* @__PURE__ */ __name((keys) => {
+      const result = [];
+      for (const key of keys) {
+        const value = map.get(key);
+        if (isDefined4(value)) {
+          result.push(value);
+        }
+      }
+      return result;
+    }, "getMany"),
+    [Symbol.iterator]: function* () {
+      for (const entry of map) {
+        yield entry;
       }
-      rewardTransferCount++;
     }
+  };
+}
+__name(mapToMapType, "mapToMapType");
+
+// src/primitives/readPayloadMapFromStore.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+function readPayloadMapFromStore(store) {
+  if (isReadArchivist(store)) {
+    return {
+      get: /* @__PURE__ */ __name(async (hash) => {
+        return (await store.get([
+          hash
+        ]))[0];
+      }, "get"),
+      getMany: /* @__PURE__ */ __name(async (hashes) => {
+        return await store.get(hashes);
+      }, "getMany"),
+      has: /* @__PURE__ */ __name(async (hash) => {
+        return isDefined5((await store.get([
+          hash
+        ]))[0]);
+      }, "has")
+    };
   }
-  assertEx5(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
-  return [
-    rewardTransferIndex,
-    rewardTransferCount
-  ];
+  return store;
 }
-__name(stepTransferIndex, "stepTransferIndex");
+__name(readPayloadMapFromStore, "readPayloadMapFromStore");
+function payloadMapFromStore(store) {
+  if (isReadWriteArchivist(store)) {
+    return {
+      get: /* @__PURE__ */ __name(async (hash) => {
+        return (await store.get([
+          hash
+        ]))[0];
+      }, "get"),
+      getMany: /* @__PURE__ */ __name(async (hashes) => {
+        return await store.get(hashes);
+      }, "getMany"),
+      has: /* @__PURE__ */ __name(async (hash) => {
+        return isDefined5((await store.get([
+          hash
+        ]))[0]);
+      }, "has"),
+      clear: /* @__PURE__ */ __name(async () => {
+        return await store.clear();
+      }, "clear"),
+      delete: /* @__PURE__ */ __name(async (id) => {
+        await store.delete([
+          id
+        ]);
+        return true;
+      }, "delete"),
+      set: /* @__PURE__ */ __name(async (_id, data) => {
+        await store.insert([
+          data
+        ]);
+      }, "set"),
+      setMany: /* @__PURE__ */ __name(async (entries) => {
+        await store.insert(entries.map((e) => e[1]));
+      }, "setMany")
+    };
+  }
+  return store;
+}
+__name(payloadMapFromStore, "payloadMapFromStore");
+
+// src/primitives/rewardFromBlockNumber.ts
+import { toFixedPoint } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
+var rewardFromBlockNumber = /* @__PURE__ */ __name((places = 18) => {
+  return (blockNumber, startingReward = asAttoXL13(toFixedPoint(500n, places)), blocksPerStep = 1e6, stepFactorNumerator = 95n, stepFactorDenominator = 100n, minBlockReward = asAttoXL13(toFixedPoint(10n, places)), creatorReward = asAttoXL13(toFixedPoint(20000000000n, places))) => {
+    if (blockNumber === 0) {
+      return creatorReward;
+    }
+    const step = Math.floor((blockNumber + blocksPerStep) / blocksPerStep);
+    const stepExp = BigInt(step - 1);
+    const poweredNumerator = stepExp > 0 ? stepFactorNumerator ** stepExp : 1n;
+    const poweredDenominator = stepExp > 0 ? stepFactorDenominator ** stepExp : 1n;
+    let reward = startingReward * poweredNumerator / poweredDenominator;
+    return asAttoXL13(reward < minBlockReward ? minBlockReward : reward);
+  };
+}, "rewardFromBlockNumber");
+
+// src/primitives/stake/activeStakeAtTimeByAddress.ts
+import { isDefined as isDefined6 } from "@xylabs/sdk-js";
+
+// src/primitives/stake/mergedAddRemoveStakeEventsByStaker.ts
+async function mergedAddRemoveStakeEventsByStaker(chainEvents, range, staked, staker) {
+  const [addedEvents, removedEvents] = await Promise.all([
+    chainEvents.stakeEvents(range, {
+      name: "StakeAdded",
+      args: {
+        staked,
+        staker
+      }
+    }),
+    chainEvents.stakeEvents(range, {
+      name: "StakeRemoved",
+      args: {
+        staked,
+        staker
+      }
+    })
+  ]);
+  const result = [
+    ...addedEvents,
+    ...removedEvents
+  ].toSorted((a, b) => a.time - b.time);
+  return result;
+}
+__name(mergedAddRemoveStakeEventsByStaker, "mergedAddRemoveStakeEventsByStaker");
+
+// src/primitives/stake/activeStakeAtTimeByAddress.ts
+async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
+  const stakeEvents = (await mergedAddRemoveStakeEventsByStaker(chain, [
+    0,
+    time
+  ], staked, staker)).toSorted((a, b) => a.time - b.time);
+  let result = 0n;
+  for (const event of stakeEvents) {
+    if (event.time > time) break;
+    if (event.args.staked !== staked) continue;
+    if (isDefined6(staker) && event.args.staker !== staker) continue;
+    if (event.name === "StakeAdded") {
+      result += event.args.amount;
+    } else if (event.name === "StakeRemoved") {
+      result -= event.args.amount;
+    }
+  }
+  return result;
+}
+__name(activeStakeAtTimeByAddress, "activeStakeAtTimeByAddress");
+
+// src/primitives/stake/activeStakeAtTimeByPosition.ts
+import { isUndefined } from "@xylabs/sdk-js";
+
+// src/primitives/stake/mergedAddRemoveStakeEventsByPosition.ts
+async function mergedAddRemoveStakeEventsByPosition(chainEvents, range, position) {
+  const [addedEvents, removedEvents] = await Promise.all([
+    chainEvents.stakeEvents(range, {
+      name: "StakeAdded",
+      args: {
+        id: position
+      }
+    }),
+    chainEvents.stakeEvents(range, {
+      name: "StakeRemoved",
+      args: {
+        id: position
+      }
+    })
+  ]);
+  const result = [
+    ...addedEvents,
+    ...removedEvents
+  ].toSorted((a, b) => a.time - b.time);
+  return result;
+}
+__name(mergedAddRemoveStakeEventsByPosition, "mergedAddRemoveStakeEventsByPosition");
+
+// src/primitives/stake/activeStakeAtTimeByPosition.ts
+async function activeStakeAtTimeByPosition(chainStakeEvents, externalTime, position) {
+  const stakeEvents = (await mergedAddRemoveStakeEventsByPosition(chainStakeEvents, [
+    0,
+    externalTime
+  ], position)).toSorted((a, b) => a.time - b.time);
+  let result = 0n;
+  for (const event of stakeEvents) {
+    if (event.time > externalTime) break;
+    if (isUndefined(position) || position === Number(event.args.id)) {
+      if (event.name === "StakeAdded") {
+        result += event.args.amount;
+      } else if (event.name === "StakeRemoved") {
+        result -= event.args.amount;
+      }
+    }
+  }
+  return result;
+}
+__name(activeStakeAtTimeByPosition, "activeStakeAtTimeByPosition");
+
+// src/primitives/stake/allStakersForRange.ts
+import { toAddress as toAddress7 } from "@xylabs/sdk-js";
+async function allStakersForRange(chain, externalRange, staked) {
+  const mergedEvents = await mergedAddRemoveStakeEventsByStaker(chain, [
+    0,
+    externalRange[1]
+  ], staked);
+  const resultWithZeros = {};
+  for (const event of mergedEvents) {
+    const staker = toAddress7(event.args.staker);
+    resultWithZeros[staker] = resultWithZeros[staker] ?? 0n;
+    if (event.name === "StakeAdded") {
+      resultWithZeros[staker] += event.args.amount;
+    } else if (event.name === "StakeRemoved") {
+      resultWithZeros[staker] -= event.args.amount;
+    }
+  }
+  const nonZero = Object.entries(resultWithZeros).filter(([, amount]) => amount > 0n).map(([address]) => address);
+  const result = {};
+  for (const address of nonZero) {
+    result[toAddress7(address)] = resultWithZeros[toAddress7(address)];
+  }
+  return result;
+}
+__name(allStakersForRange, "allStakersForRange");
+
+// src/primitives/stake/allStakersForStep.ts
+async function allStakersForStep(context, blockViewer, stepContext, staked) {
+  const xl1BlockRange = stepBlockRange(stepContext);
+  return await allStakersForRange(context.stake.stakeEvents, await externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange), staked);
+}
+__name(allStakersForStep, "allStakersForStep");
+
+// src/primitives/stake/weightedStakeForRangeByPosition.ts
+import { isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { asBlockNumber as asBlockNumber2 } from "@xyo-network/xl1-protocol";
+async function weightedStakeForRangeByPosition(context, blockViewer, externalRange, positionId) {
+  const cacheKey = isDefined7(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`;
+  return await withContextCacheResponse(context, "weightedStakeForRangeByPosition", cacheKey, async () => {
+    let weightedStakeSum = 0n;
+    if (isDefined7(positionId)) {
+      const mergedEvents = (await mergedAddRemoveStakeEventsByPosition(context.stake.stakeEvents, [
+        0,
+        externalRange[1]
+      ], positionId)).toSorted((a, b) => a.time - b.time);
+      let currentTime = externalRange[0];
+      let currentStake = 0n;
+      for (const event of mergedEvents) {
+        if (event.time > currentTime) {
+          weightedStakeSum += currentStake * BigInt(event.time - currentTime);
+        }
+        if (event.name === "StakeAdded") {
+          currentStake += event.args.amount;
+        } else if (event.name === "StakeRemoved") {
+          currentStake -= event.args.amount;
+        }
+        currentStake = currentStake < 0n ? 0n : currentStake;
+        currentTime = asBlockNumber2(event.time, {
+          name: "weightedStakeForRangeByPosition"
+        });
+        if (currentTime > externalRange[1]) {
+          break;
+        }
+      }
+      if (externalRange[1] > currentTime) {
+        weightedStakeSum += currentStake * BigInt(externalRange[1] - currentTime);
+      }
+    } else {
+      const positionCount = await context.stake.stakeEvents.positionCount(externalRange);
+      for (let pos = 0; pos < positionCount; pos++) {
+        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, pos);
+      }
+    }
+    return weightedStakeSum;
+  });
+}
+__name(weightedStakeForRangeByPosition, "weightedStakeForRangeByPosition");
+
+// src/primitives/rewards/networkStakeStepRewardPositionWeight.ts
+async function networkStakeStepRewardPositionWeight(context, blockViewer, stepContext, position) {
+  const result = await weightedStakeForRangeByPosition(context, blockViewer, await externalBlockRangeFromStep(context, blockViewer, stepContext), position);
+  return result;
+}
+__name(networkStakeStepRewardPositionWeight, "networkStakeStepRewardPositionWeight");
 
 // src/primitives/timeBudget.ts
 async function timeBudget(name, logger, func, budget, status = false) {
@@ -400,12 +945,89 @@ function elevatedPayloads([tx, payloads]) {
 }
 __name(elevatedPayloads, "elevatedPayloads");
 
+// src/primitives/uncle/scoreUncle.ts
+function scoreUncle(finalizedWindowedChain, blocks) {
+  return blocks.length;
+}
+__name(scoreUncle, "scoreUncle");
+
+// src/primitives/uncle/findBestUncle.ts
+function findBestUncle(finalizedWindowedChain, uncles) {
+  const scores = uncles.map((uncle) => [
+    scoreUncle(finalizedWindowedChain, uncle),
+    uncle
+  ]).toSorted((a, b) => b[0] - a[0]);
+  return scores[0]?.[1] ?? finalizedWindowedChain;
+}
+__name(findBestUncle, "findBestUncle");
+
+// src/primitives/uncle/findUncles.ts
+import { assertEx as assertEx10, exists as exists2 } from "@xylabs/sdk-js";
+import { isTransactionBoundWitness as isTransactionBoundWitness2 } from "@xyo-network/xl1-protocol";
+function blocksToChains(blocks) {
+  const chains = [];
+  const map = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    map.set(block[0]._hash, block);
+  }
+  for (const block of blocks) {
+    let uncle = [
+      block
+    ];
+    let previous = block[0].previous ? map.get(block[0].previous) : void 0;
+    while (previous) {
+      if (previous[0].block === uncle[0][0].block - 1) {
+        uncle.unshift(previous);
+        previous = previous[0].previous ? map.get(previous[0].previous) : void 0;
+      } else {
+        uncle = [];
+        break;
+      }
+    }
+    if (uncle.length > 0) {
+      chains.push(uncle);
+    }
+  }
+  return chains;
+}
+__name(blocksToChains, "blocksToChains");
+function toValidUncle(_context, finalizedWindowedChain, possibleUncle) {
+  const finalizedWindowStartBlockNumber = finalizedWindowedChain.at(0)?.[0].block ?? -1;
+  const finalizedHead = assertEx10(finalizedWindowedChain.at(-1), () => "finalizedWindowedChain is empty");
+  const prunedPossibleUncle = possibleUncle.filter((b) => b[0].block > finalizedHead[0].block);
+  if (prunedPossibleUncle.length === 0) {
+    return;
+  }
+  if (prunedPossibleUncle[0][0].block !== finalizedHead[0].block + 1) {
+    return;
+  }
+  if (prunedPossibleUncle[0][0].previous !== finalizedHead[0]._hash) {
+    return;
+  }
+  const allUncleTransactions = prunedPossibleUncle.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
+  const allFinalizedTransactions = finalizedWindowedChain.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
+  const txPossiblyBeforeWindow = allUncleTransactions.find((tx) => tx.nbf < finalizedWindowStartBlockNumber);
+  if (txPossiblyBeforeWindow) {
+    return;
+  }
+  const txExistsInWindow = allUncleTransactions.find((tx) => allFinalizedTransactions.find((finalTx) => finalTx._hash === tx._hash));
+  if (txExistsInWindow) {
+    return;
+  }
+  return prunedPossibleUncle;
+}
+__name(toValidUncle, "toValidUncle");
+function findUncles(context, finalizedWindowedChain, blocks) {
+  return blocksToChains(blocks).map((chain) => toValidUncle(context, finalizedWindowedChain, chain)).filter(exists2);
+}
+__name(findUncles, "findUncles");
+
 // src/model/ChainContext/ChainContext.ts
 function contextCache(context, name, create) {
   if (!context.caches) {
     context.caches = {};
   }
-  if (isUndefined(context.caches[name])) {
+  if (isUndefined2(context.caches[name])) {
     context.caches[name] = create?.() ?? new MemoryMap();
   }
   return context.caches[name];
@@ -416,7 +1038,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
     max
   }));
   const cacheResult = await cache.get(key);
-  if (isDefined4(cacheResult)) {
+  if (isDefined8(cacheResult)) {
     return cacheResult;
   }
   const result = timeBudgetMs > 0 ? await timeBudget(name, context.logger, func, timeBudgetMs) : await func();
@@ -425,6 +1047,44 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
 }
 __name(withContextCacheResponse, "withContextCacheResponse");
 
+// src/model/ChainQualification.ts
+import { HashZod } from "@xylabs/hex";
+import { zodIsFactory } from "@xylabs/zod";
+import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import z from "zod";
+var ChainQualificationZod = z.object({
+  head: HashZod,
+  range: XL1BlockRangeZod
+});
+var isChainQualification = zodIsFactory(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z.object({
+  range: XL1BlockRangeZod
+});
+var isChainQualifiedRangeConfig = zodIsFactory(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z.object({
+  head: HashZod
+});
+var isChainQualifiedHeadConfig = zodIsFactory(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z.union([
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedHeadConfigZod,
+  z.object({})
+]);
+var isChainQualifiedConfig = zodIsFactory(ChainQualifiedConfigZod);
+var ExtendChainQualifiedConfigZod = /* @__PURE__ */ __name((zodType) => {
+  return z.union([
+    ChainQualifiedRangeConfigZod.extend(zodType),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType
+  ]);
+}, "ExtendChainQualifiedConfigZod");
+var ChainQualifiedZod = /* @__PURE__ */ __name((zodType) => {
+  return z.tuple([
+    zodType,
+    ChainQualificationZod
+  ]);
+}, "ChainQualifiedZod");
+
 // src/model/PayloadBundle/bundledPayloadToHydratedBlock.ts
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { asSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
@@ -471,13 +1131,36 @@ var bundle = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema as PayloadBundleSchema2 } from "@xyo-network/payload-model";
 
+// src/transaction/buildRandomTransaction.ts
+import { Account } from "@xyo-network/account";
+import { asXL1BlockNumber as asXL1BlockNumber2, isAllowedBlockPayload as isAllowedBlockPayload2 } from "@xyo-network/xl1-protocol";
+
+// src/createTransferPayload.ts
+import { toHex } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { TransferSchema } from "@xyo-network/xl1-protocol";
+function createTransferPayload(from, transfers, context) {
+  return new PayloadBuilder4({
+    schema: TransferSchema
+  }).fields({
+    epoch: Date.now(),
+    from,
+    transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [
+      k,
+      toHex(v)
+    ])),
+    context
+  }).build();
+}
+__name(createTransferPayload, "createTransferPayload");
+
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx6, toHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, toHex as toHex2 } from "@xylabs/sdk-js";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees } from "@xyo-network/xl1-protocol";
 async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
   if (from === void 0 && Array.isArray(signer)) {
@@ -486,22 +1169,22 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   const txBoundWitnessFields = {
     chain,
     fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority)
+      base: toHex2(fees.base),
+      gasLimit: toHex2(fees.gasLimit),
+      gasPrice: toHex2(fees.gasPrice),
+      priority: toHex2(fees.priority)
     },
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder4.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder5.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx6(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx11(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -515,30 +1198,49 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     signer
   ]).build();
   return [
-    await PayloadBuilder4.addHashMeta(tx),
-    await PayloadBuilder4.addHashMeta(txPayloads)
+    await PayloadBuilder5.addHashMeta(tx),
+    await PayloadBuilder5.addHashMeta(txPayloads)
   ];
 }
 __name(buildTransaction, "buildTransaction");
 
+// src/transaction/buildRandomTransaction.ts
+var buildRandomTransaction = /* @__PURE__ */ __name(async (chain, payloads, account, nbf = asXL1BlockNumber2(0, true), exp = asXL1BlockNumber2(nbf + 1e3, true), privatePayloadSchemas = [], receiverAddress) => {
+  const elevatedPayloads2 = (payloads ?? []).filter(isAllowedBlockPayload2);
+  const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload2(payload));
+  const sender = account ?? await Account.random();
+  if (elevatedPayloads2?.length === 0) {
+    const receiver = receiverAddress ?? (await Account.random()).address;
+    const transferPayload = createTransferPayload(sender.address, {
+      [receiver]: 1n
+    });
+    elevatedPayloads2.push(transferPayload);
+  }
+  const hydratedTransaction = await buildTransaction(chain, elevatedPayloads2, additionalPayloads, sender, nbf, exp);
+  return [
+    hydratedTransaction[0],
+    hydratedTransaction[1].filter((p) => !privatePayloadSchemas.includes(p.schema))
+  ];
+}, "buildRandomTransaction");
+
 // src/transaction/buildUnsignedTransaction.ts
-import { toHex as toHex2 } from "@xylabs/sdk-js";
+import { toHex as toHex3 } from "@xylabs/sdk-js";
 import { BoundWitnessBuilder as BoundWitnessBuilder2 } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees as defaultTransactionFees2 } from "@xyo-network/xl1-protocol";
 async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads, nbf, exp, from, fees = defaultTransactionFees2) {
   const txBoundWitnessFields = {
     chain,
     fees: {
-      base: toHex2(fees.base),
-      gasLimit: toHex2(fees.gasLimit),
-      gasPrice: toHex2(fees.gasPrice),
-      priority: toHex2(fees.priority)
+      base: toHex3(fees.base),
+      gasLimit: toHex3(fees.gasLimit),
+      gasPrice: toHex3(fees.gasPrice),
+      priority: toHex3(fees.priority)
     },
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder5.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder6.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
@@ -564,7 +1266,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
-import { delay, isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { delay, isDefined as isDefined9 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash, options) => {
@@ -573,7 +1275,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txHash) ?? void 0;
-    if (isDefined5(tx)) {
+    if (isDefined9(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
       return tx;
     } else {
@@ -590,9 +1292,9 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
-import { asSignedHydratedTransaction, isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { asSignedHydratedTransaction, isAllowedBlockPayload as isAllowedBlockPayload3, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
   return await tryHydrateTypedBoundWitness({
     get(hashes) {
@@ -644,7 +1346,7 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
     const [code, hash2] = opCode.split("|");
     if (code === "elevated") {
       const elevatedPayload = payloads.find((payload) => payload._hash === hash2);
-      if (isAllowedBlockPayload2(elevatedPayload)) {
+      if (isAllowedBlockPayload3(elevatedPayload)) {
         elevatedPayloads2.push(elevatedPayload);
       }
     }
@@ -658,15 +1360,15 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx7(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx12(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder6.omitStorageMeta(transaction);
+  const cleanTransaction = PayloadBuilder7.omitStorageMeta(transaction);
   const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder6.omitStorageMeta(payloads);
+  const cleanPayloads = PayloadBuilder7.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
 __name(transactionBlockByteCount, "transactionBlockByteCount");
@@ -724,7 +1426,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { asHash as asHash2 } from "@xylabs/sdk-js";
-import { assertEx as assertEx8, filterAs } from "@xylabs/sdk-js";
+import { assertEx as assertEx13, filterAs } from "@xylabs/sdk-js";
 import { isAllowedBlockPayloadWithHashMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
@@ -733,7 +1435,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs(hashes, (h) => asHash2(h));
-  assertEx8(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx13(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -747,15 +1449,15 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx8(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx13(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
-import { assertEx as assertEx9, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx14, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx9(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx14(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [
     account.address
@@ -763,7 +1465,7 @@ async function signTransaction(tx, account) {
   unsignedTx.previous_hashes = [
     account.previousHash ?? null
   ];
-  const hash = await PayloadBuilder7.dataHash(unsignedTx);
+  const hash = await PayloadBuilder8.dataHash(unsignedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
   const result = {
@@ -776,14 +1478,126 @@ async function signTransaction(tx, account) {
 }
 __name(signTransaction, "signTransaction");
 
+// src/transaction/TransactionBuilder.ts
+import { assertEx as assertEx15, Base } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { asXL1BlockNumber as asXL1BlockNumber3, defaultTransactionFees as defaultTransactionFees3, isAllowedBlockPayload as isAllowedBlockPayload4, minTransactionFees, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
+var TransactionBuilder = class extends Base {
+  static {
+    __name(this, "TransactionBuilder");
+  }
+  _blockRange;
+  _chain;
+  _elevatedPayloads = [];
+  _fees;
+  _payloads = [];
+  _signers = [];
+  constructor(options = {}) {
+    super(options);
+  }
+  async build() {
+    const chain = assertEx15(this._chain, () => "Chain must be set before building the transaction");
+    const fees = assertEx15(this._fees, () => "Fees must be set before building the transaction");
+    const blockRange = assertEx15(this._blockRange, () => "Block range must be set before building the transaction");
+    return await buildTransaction(chain, this._elevatedPayloads, this._payloads, this._signers, asXL1BlockNumber3(blockRange[0], true), asXL1BlockNumber3(blockRange[1], true), this._signers[0]?.address, fees);
+  }
+  chain(chain) {
+    this._chain = chain;
+    return this;
+  }
+  async dryRun() {
+    return await buildTransaction(XYO_ZERO_ADDRESS, this._elevatedPayloads, this._payloads, this._signers, asXL1BlockNumber3(0, true), asXL1BlockNumber3(1e3, true), this._signers[0]?.address, defaultTransactionFees3);
+  }
+  elevatedPayload(payload) {
+    const allowedPayload = isAllowedBlockPayload4(payload) ? payload : void 0;
+    const allowPayloadExists = assertEx15(allowedPayload, () => "Payload must be an AllowedBlockPayload");
+    this._elevatedPayloads.push(allowPayloadExists);
+    return this;
+  }
+  elevatedPayloads(payloads) {
+    if (payloads) for (const payload of payloads) {
+      this.elevatedPayload(payload);
+    }
+    return this;
+  }
+  async estimatedMinimumFees() {
+    const tx = await this.dryRun();
+    const requiredGas = transactionRequiredGas(tx);
+    return {
+      base: minTransactionFees.base,
+      // eslint-disable-next-line unicorn/prefer-math-min-max
+      gasLimit: requiredGas > minTransactionFees.gasLimit ? requiredGas : minTransactionFees.gasLimit,
+      gasPrice: minTransactionFees.gasPrice,
+      priority: minTransactionFees.priority
+    };
+  }
+  fees(fees) {
+    this._fees = fees;
+    return this;
+  }
+  payload(payload) {
+    this._payloads.push(payload);
+    return this;
+  }
+  payloads(payloads) {
+    if (payloads) for (const payload of payloads) {
+      if (payload !== null) {
+        this.payload(payload);
+      }
+    }
+    return this;
+  }
+  range(blockRange) {
+    if (blockRange.length !== 2) {
+      throw new Error("Block range must be an array of two numbers");
+    }
+    this._blockRange = blockRange;
+    return this;
+  }
+  async removeElevatedPayload(payload) {
+    const hash = await PayloadBuilder9.hash(payload);
+    const existingHashes = await PayloadBuilder9.hashes(this._elevatedPayloads);
+    const existingPayloadIndex = existingHashes.indexOf(hash);
+    if (existingPayloadIndex === -1) {
+      throw new Error("Payload not found in the transaction");
+    }
+    this._elevatedPayloads = this._elevatedPayloads.filter((_, index) => index !== existingPayloadIndex);
+    return this;
+  }
+  async removePayload(payload) {
+    const hash = await PayloadBuilder9.hash(payload);
+    const existingHashes = await PayloadBuilder9.hashes(this._payloads);
+    const existingPayloadIndex = existingHashes.indexOf(hash);
+    if (existingPayloadIndex === -1) {
+      throw new Error("Payload not found in the transaction");
+    }
+    this._payloads = this._payloads.filter((_, index) => index !== existingPayloadIndex);
+    return this;
+  }
+  signer(signer) {
+    if (signer) {
+      this._signers.push(signer);
+    }
+    return this;
+  }
+  signers(signers) {
+    if (signers) for (const signer of signers) {
+      if (signer !== null) {
+        this.signer(signer);
+      }
+    }
+    return this;
+  }
+};
+
 // src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
 var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
   const root = transaction[0]._hash;
   return bundle2(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle2 = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder8.omitStorageMeta(p));
-  return new PayloadBuilder8({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder10.omitStorageMeta(p));
+  return new PayloadBuilder10({
     schema: PayloadBundleSchema2
   }).fields({
     payloads,
@@ -792,32 +1606,20 @@ var bundle2 = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/model/Provider.ts
-import { assertEx as assertEx10, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx16, isString } from "@xylabs/sdk-js";
 var asProviderMoniker = /* @__PURE__ */ __name((value) => {
   const moniker = isString(value) ? value : void 0;
-  return assertEx10(moniker);
+  return assertEx16(moniker);
 }, "asProviderMoniker");
 var DefaultProviderMoniker = "Provider";
 
-// src/model/Qualified.ts
-import { HashZod } from "@xylabs/sdk-js";
-import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
-import z from "zod";
-var QualifiedZod = /* @__PURE__ */ __name((zodType) => {
-  return z.tuple([
-    zodType,
-    XL1BlockRangeZod,
-    HashZod
-  ]);
-}, "QualifiedZod");
-
 // src/block/primitives/blockFromBlockNumber.ts
 async function blockFromBlockNumber(context, blockNumber) {
   const cacheKey = `${blockNumber}`;
   return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
     const [headHash] = await context.head();
     const result = await context.store.chainMap.get(headHash);
-    if (!isDefined6(result)) {
+    if (!isDefined10(result)) {
       throw new Error(`Head block not found for hash: ${headHash}`);
     }
     let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(result, () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`);
@@ -827,7 +1629,7 @@ async function blockFromBlockNumber(context, blockNumber) {
     while (currentBlock.block > blockNumber) {
       let jumpHash = currentBlock.previous;
       let jumpBlockNumber = currentBlock.block - 1;
-      for (const [step, stepSize2] of StepSizes4.entries()) {
+      for (const [step, stepSize2] of StepSizes6.entries()) {
         const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
         if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
           jumpBlockNumber = possibleJumpBlockNumber;
@@ -835,7 +1637,7 @@ async function blockFromBlockNumber(context, blockNumber) {
         }
       }
       const newBlock = await context.store.chainMap.get(asHash3(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
-      if (!isDefined6(newBlock)) {
+      if (!isDefined10(newBlock)) {
         throw new Error(`Block not found for jump hash: ${jumpHash}`);
       }
       currentBlock = asSignedBlockBoundWitnessWithStorageMeta(newBlock, () => {
@@ -855,7 +1657,7 @@ async function blockFromBlockNumber(context, blockNumber) {
 __name(blockFromBlockNumber, "blockFromBlockNumber");
 
 // src/block/primitives/frames/calculateFramesFromRange.ts
-import { asXL1BlockNumber, stepSize } from "@xyo-network/xl1-protocol";
+import { asXL1BlockNumber as asXL1BlockNumber4, stepSize } from "@xyo-network/xl1-protocol";
 function calculateFramesFromRange(range, step) {
   const size = stepSize(step);
   let start = Math.trunc(range[0] / size) * size;
@@ -865,22 +1667,22 @@ function calculateFramesFromRange(range, step) {
     start += size;
     remaining.push([
       range[0],
-      asXL1BlockNumber(Math.min(start - 1, range[1]), true)
+      asXL1BlockNumber4(Math.min(start - 1, range[1]), true)
     ]);
   }
   for (let i = start; i <= range[1]; i += size) {
     if (i + size - 1 <= range[1]) {
       fitted.push([
-        asXL1BlockNumber(i, {
+        asXL1BlockNumber4(i, {
           name: "calculateFramesFromRange A"
         }),
-        asXL1BlockNumber(Math.min(i + size - 1, range[1]), {
+        asXL1BlockNumber4(Math.min(i + size - 1, range[1]), {
           name: "calculateFramesFromRange B"
         })
       ]);
     } else {
       remaining.push([
-        asXL1BlockNumber(i, {
+        asXL1BlockNumber4(i, {
           name: "calculateFramesFromRange C"
         }),
         range[1]
@@ -895,8 +1697,8 @@ function calculateFramesFromRange(range, step) {
 __name(calculateFramesFromRange, "calculateFramesFromRange");
 
 // src/block/primitives/frames/deepCalculateFramesFromRange.ts
-import { StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
-function deepCalculateFramesFromRange(range, startingStep = StepSizes5.length - 1) {
+import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
+function deepCalculateFramesFromRange(range, startingStep = StepSizes7.length - 1) {
   const fitted = [];
   let remaining = [
     range
@@ -949,7 +1751,7 @@ function toStepIdentityString({ block, step }) {
 __name(toStepIdentityString, "toStepIdentityString");
 
 // src/config/Bridge.ts
-import { AddressZod, HexZod, toAddress as toAddress3, toHex as toHex3 } from "@xylabs/hex";
+import { AddressZod, HexZod, toAddress as toAddress8, toHex as toHex4 } from "@xylabs/hex";
 import { AttoXL1ConvertFactor, XL1 } from "@xyo-network/xl1-protocol";
 import { globalRegistry } from "zod";
 import * as z3 from "zod";
@@ -1016,12 +1818,13 @@ var MnemonicStringZod = z2.string().transform((s) => s.trim().replaceAll(/\s+/g,
 }).describe("BIP-39 mnemonic string");
 
 // src/config/Bridge.ts
-var DEFAULT_FIXED_FEE = toHex3(XL1(1n) * AttoXL1ConvertFactor.xl1);
-var DEFAULT_MIN_BRIDGE_AMOUNT = toHex3(XL1(10n) * AttoXL1ConvertFactor.xl1);
-var DEFAULT_MAX_BRIDGE_AMOUNT = toHex3(XL1(100000n) * AttoXL1ConvertFactor.xl1);
-var DEFAULT_HARDHAT_CHAIN_ID = toHex3("7A69");
-var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress3("5FbDB2315678afecb367f032d93F642f64180aa3");
-var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress3("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
+var DEFAULT_FIXED_FEE = toHex4(XL1(1n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress8("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
+var DEFAULT_HARDHAT_CHAIN_ID = toHex4("7A69");
+var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex4("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress8("5FbDB2315678afecb367f032d93F642f64180aa3");
+var DEFAULT_MAX_BRIDGE_AMOUNT = toHex4(XL1(100000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_MIN_BRIDGE_AMOUNT = toHex4(XL1(10n) * AttoXL1ConvertFactor.xl1);
 var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = z3.object({
   chainRpcApiUrl: z3.string().default("http://localhost:8080/rpc").register(globalRegistry, {
@@ -1075,12 +1878,24 @@ var BridgeConfigZod = z3.object({
     title: "bridge.mnemonic",
     type: "string"
   }),
-  port: z3.coerce.number().default(8081).register(globalRegistry, {
+  port: z3.coerce.number().int().positive().default(8081).register(globalRegistry, {
     default: 8081,
     description: "Port for the Bridge",
     title: "bridge.port",
     type: "number"
   }),
+  redisHost: z3.string().default("localhost").register(globalRegistry, {
+    default: "localhost",
+    description: "Host for the Bridge Redis instance",
+    title: "bridge.redisHost",
+    type: "string"
+  }),
+  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry, {
+    default: 6379,
+    description: "Port for the Bridge Redis instance",
+    title: "bridge.redisPort",
+    type: "number"
+  }),
   remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry, {
     default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
@@ -1099,6 +1914,11 @@ var BridgeConfigZod = z3.object({
     title: "bridge.remoteTokenAddress",
     type: "string"
   }),
+  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry, {
+    description: "Private key for the wallet to use for the remote chain wallet",
+    title: "bridge.remoteChainWalletPrivateKey",
+    type: "string"
+  }),
   xl1ChainId: HexZod.optional().register(globalRegistry, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
@@ -1158,11 +1978,11 @@ var ApiConfigZod = z4.object({
 });
 
 // src/config/Chain.ts
-import { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod2, HexZod as HexZod2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry3 } from "zod";
 import * as z5 from "zod";
 var ChainConfigZod = z5.object({
-  id: z5.string().optional().register(globalRegistry3, {
+  id: HexZod2.optional().register(globalRegistry3, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
     type: "string"
@@ -1366,12 +2186,14 @@ var RewardRedemptionApiConfigZod = z10.object({
 import { globalRegistry as globalRegistry9 } from "zod";
 import * as z11 from "zod";
 var ServicesConfigZod = z11.object({
-  accountBalanceViewerEndpoint: z11.string().optional().register(globalRegistry9, {
+  accountBalanceViewerEndpoint: z11.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+    default: "http://localhost:8080/rpc",
     description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
     title: "services.accountBalanceViewerEndpoint",
     type: "string"
   }),
-  apiEndpoint: z11.string().optional().register(globalRegistry9, {
+  apiEndpoint: z11.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+    default: "http://localhost:8080/rpc",
     description: "Endpoint of the API to use for instantiating an external Viewers",
     title: "services.apiEndpoint",
     type: "string"
@@ -1379,12 +2201,12 @@ var ServicesConfigZod = z11.object({
 });
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined7, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined11, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry10 } from "zod";
 import * as z12 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
-  if (isUndefined2(config)) return false;
-  return isDefined7(config.connectionString) && isDefined7(config.database) && isDefined7(config.domain) && isDefined7(config.password) && isDefined7(config.username);
+  if (isUndefined3(config)) return false;
+  return isDefined11(config.connectionString) && isDefined11(config.database) && isDefined11(config.domain) && isDefined11(config.password) && isDefined11(config.username);
 }, "hasMongoConfig");
 var MongoConfigZod = z12.object({
   // TODO: Create from other arguments
@@ -1546,15 +2368,11 @@ function isUsageMeta(v) {
 }
 __name(isUsageMeta, "isUsageMeta");
 
-// src/constants.ts
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH = 1760572800;
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK = 107496;
-
 // src/CreatableProvider/AbstractCreatableProvider.ts
-import { AbstractCreatable } from "@xylabs/sdk-js";
+import { AbstractCreatable, assertEx as assertEx18 } from "@xylabs/sdk-js";
 
 // src/CreatableProvider/ProviderFactory.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17 } from "@xylabs/sdk-js";
 var ProviderFactory = class _ProviderFactory {
   static {
     __name(this, "ProviderFactory");
@@ -1564,30 +2382,80 @@ var ProviderFactory = class _ProviderFactory {
   defaultParams;
   labels;
   monikers;
-  constructor(creatableProvider2, params, labels = {}) {
+  scope;
+  constructor(creatableProvider2, params, labels = {}, scope = "context") {
     this.creatableProvider = creatableProvider2;
     this.defaultParams = params;
     this.defaultMoniker = creatableProvider2.defaultMoniker;
     this.monikers = creatableProvider2.monikers;
-    assertEx11(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
+    this.scope = scope;
+    assertEx17(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
     this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
   }
+  get resolvedMoniker() {
+    const labels = this.labels ?? {};
+    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
+    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`;
+  }
   static withParams(creatableProvider2, params, labels = {}) {
     return new _ProviderFactory(creatableProvider2, params, labels);
   }
-  create(params) {
+  /** @deprecated use getInstance instead */
+  async create(params, start = true) {
+    return await this.getInstance(params, start);
+  }
+  factory(params, labels = {}) {
+    return new _ProviderFactory(this.creatableProvider, params, labels);
+  }
+  async getInstance(params, start = true) {
+    let scopeObject = {};
+    switch (this.scope) {
+      case "global": {
+        if (globalThis.xyoServiceSingletons === void 0) {
+          globalThis.xyoServiceSingletons = {};
+        }
+        scopeObject = globalThis.xyoServiceSingletons;
+        break;
+      }
+      case "context": {
+        const context = assertEx17(params?.context, () => "Context is required for context-scoped providers");
+        if (context.singletons === void 0) {
+          context.singletons = {};
+        }
+        scopeObject = context.singletons;
+        break;
+      }
+      default: {
+        scopeObject = {};
+        break;
+      }
+    }
     const mergedParams = {
       ...this.defaultParams,
       ...params,
-      config: {
-        ...this.defaultParams?.config,
-        ...params?.config
+      context: {
+        ...this.defaultParams?.context,
+        ...params?.context,
+        config: {
+          ...this.defaultParams?.context?.config,
+          ...params?.context?.config
+        }
       }
     };
-    return this.creatableProvider.create(mergedParams);
+    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
+    scopeObject[this.resolvedMoniker] = resultPromise;
+    const result = await resultPromise;
+    if (start) {
+      assertEx17(await result.start(), () => "Failed to start provider instance");
+    }
+    return result;
   }
-  factory(params, labels = {}) {
-    return new _ProviderFactory(this.creatableProvider, params, labels);
+  async tryGetInstance(params, start = true) {
+    try {
+      return await this.getInstance(params, start);
+    } catch {
+      return;
+    }
   }
 };
 
@@ -1596,8 +2464,48 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
   static {
     __name(this, "AbstractCreatableProvider");
   }
+  _contextCache;
+  get config() {
+    return this.context.config;
+  }
+  get context() {
+    return this.params.context;
+  }
+  get locator() {
+    return this.context.locator;
+  }
   static factory(params) {
-    return ProviderFactory.withParams(this, params);
+    const factory = ProviderFactory.withParams(this, params);
+    return factory;
+  }
+  static async getInstance(inParams) {
+    const instance = await this.create(inParams);
+    return instance;
+  }
+  static async paramsHandler(params = {}) {
+    const context = assertEx18(params.context, () => new Error("Context is required"));
+    const config = assertEx18(context.config, () => new Error("Context config is required"));
+    const locator = assertEx18(context.locator, () => new Error("Context locator is required"));
+    return await super.paramsHandler({
+      ...params,
+      statusReporter: params.statusReporter ?? context.statusReporter,
+      context: {
+        ...context,
+        config,
+        locator
+      },
+      name: params.name ?? this.defaultMoniker
+    });
+  }
+  static async tryGetInstance(inParams) {
+    try {
+      return await this.create(inParams);
+    } catch {
+      return;
+    }
+  }
+  async locateAndCreate(moniker) {
+    return await this.locator?.getInstance(moniker);
   }
 };
 
@@ -1619,16 +2527,22 @@ __name(labeledCreatableProvider, "labeledCreatableProvider");
 import { isTruthy } from "@xylabs/sdk-js";
 var buildProviderFactory = /* @__PURE__ */ __name((provider, labels) => {
   const factory = {
-    // Destructure instance properties
-    ...provider,
     monikers: provider.monikers,
     // Copy static methods
+    // eslint-disable-next-line sonarjs/deprecation
     create: provider.create.bind(provider),
     // Merge module & supplied labels
     labels: {
       ...provider.labels,
       ...labels
-    }
+    },
+    creatableProvider: provider.creatableProvider,
+    resolvedMoniker: provider.resolvedMoniker,
+    scope: provider.scope,
+    getInstance: provider.getInstance.bind(provider),
+    tryGetInstance: provider.tryGetInstance?.bind(provider),
+    defaultMoniker: provider.defaultMoniker,
+    factory: provider.factory.bind(provider)
   };
   return factory;
 }, "buildProviderFactory");
@@ -1692,15 +2606,23 @@ __name(labeledCreatableProviderFactory, "labeledCreatableProviderFactory");
 
 // src/CreatableProvider/ProviderFactoryLocator.ts
 import { hasAllLabels } from "@xylabs/sdk-js";
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { assertEx as assertEx19 } from "@xylabs/sdk-js";
 var ProviderFactoryLocator = class _ProviderFactoryLocator {
   static {
     __name(this, "ProviderFactoryLocator");
   }
+  _context;
   _registry;
   _frozen = false;
-  constructor(registry = {}) {
+  constructor(context, registry = {}) {
     this._registry = registry;
+    this._context = {
+      ...context,
+      locator: this
+    };
+  }
+  get context() {
+    return this._context;
   }
   /**
   * The current registry for the module factory
@@ -1708,23 +2630,39 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
   get registry() {
     return this._registry;
   }
-  static empty() {
-    return new _ProviderFactoryLocator({});
+  static empty(context) {
+    return new _ProviderFactoryLocator(context, {});
   }
-  static standard() {
-    return new _ProviderFactoryLocator({});
+  static standard(context) {
+    return new _ProviderFactoryLocator(context, {});
+  }
+  /** @deprecated use getInstance instead */
+  async create(moniker, params, labels) {
+    return await this.getInstance(moniker, params, labels);
   }
   freeze() {
     this._frozen = true;
   }
+  async getInstance(moniker, params, labels) {
+    const resolvedParams = {
+      ...params,
+      context: {
+        ...this.context,
+        ...params?.context
+      }
+    };
+    const factory = this.locate(moniker, labels);
+    const result = await factory.getInstance(resolvedParams);
+    return result;
+  }
   /**
-  * Locates a provider factory that matches the supplied schema and labels
-  * @param schema The config schema for the provider
+  * Locates a provider factory that matches the supplied moniker and labels
+  * @param moniker The config moniker for the provider
   * @param labels The labels for the provider factory
-  * @returns A provider factory that matches the supplied schema and labels or throws if one is not found
+  * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
   */
   locate(moniker, labels) {
-    return assertEx12(this.tryLocate(moniker, labels), () => `No module factory for the supplied config schema [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`);
+    return assertEx19(this.tryLocate(moniker, labels), () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`);
   }
   merge(locator) {
     const registry = {
@@ -1737,7 +2675,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
         registry[moniker] = locator.registry[moniker];
       }
     }
-    return new _ProviderFactoryLocator(registry);
+    return new _ProviderFactoryLocator(this.context, registry);
   }
   /**
   * Registers a single module factory (with optional tags) with the locator
@@ -1745,7 +2683,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
   * @param labels The labels for the module factory
   */
   register(factory, labels, primary = false) {
-    assertEx12(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    assertEx19(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
     registerCreatableProviderFactory(this._registry, factory, labels, primary);
     return this;
   }
@@ -1759,19 +2697,53 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     }
     return this;
   }
+  async tryGetInstance(moniker, params, labels) {
+    try {
+      return await this.getInstance(moniker, params, labels);
+    } catch {
+      return;
+    }
+  }
   /**
-  * Tries to locate a module factory that matches the supplied schema and labels
-  * @param schema The config schema for the module
+  * Tries to locate a module factory that matches the supplied moniker and labels
+  * @param moniker The config moniker for the module
   * @param labels The labels for the module factory
-  * @returns A module factory that matches the supplied schema and labels or undefined
+  * @returns A module factory that matches the supplied moniker and labels or undefined
   */
   tryLocate(moniker, labels) {
-    return labels ? this._registry[moniker]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0] : this._registry[moniker]?.[0];
+    const result = labels ? this._registry[moniker]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0] : this._registry[moniker]?.[0];
+    if (result) {
+      result.defaultParams = {
+        ...result?.defaultParams,
+        context: {
+          ...this.context,
+          ...result?.defaultParams?.context
+        }
+      };
+    }
+    return result;
   }
 };
 
+// src/createDeclarationPayload.ts
+import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { ChainStakeIntentSchema } from "@xyo-network/xl1-protocol";
+var createDeclarationIntent = /* @__PURE__ */ __name((address, intent, nbf, exp) => {
+  const expiration = isDefined12(exp) ? exp : nbf + 1e4;
+  const redeclarationIntent = new PayloadBuilder11({
+    schema: ChainStakeIntentSchema
+  }).fields({
+    from: address,
+    intent,
+    nbf,
+    exp: expiration
+  }).build();
+  return redeclarationIntent;
+}, "createDeclarationIntent");
+
 // src/eip-712/Payloads/EIP712Data.ts
-import { AsObjectFactory } from "@xylabs/sdk-js";
+import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
 import { isPayloadOfZodType } from "@xyo-network/payload-model";
 import z19 from "zod";
 
@@ -1806,10 +2778,10 @@ var EIP712DataPayloadFieldsZod = z19.object({
 });
 var EIP712DataPayloadSchema = "network.xyo.chains.ethereum.eip712.data";
 var isEIP712DataPayload = isPayloadOfZodType(EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema);
-var asEIP712DataPayload = AsObjectFactory.create(isEIP712DataPayload);
+var asEIP712DataPayload = AsObjectFactory2.create(isEIP712DataPayload);
 
 // src/eip-712/Payloads/EIP712Signature.ts
-import { AsObjectFactory as AsObjectFactory2, HashZod as HashZod2 } from "@xylabs/sdk-js";
+import { AsObjectFactory as AsObjectFactory3, HashZod as HashZod2 } from "@xylabs/sdk-js";
 import { isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/payload-model";
 import z20 from "zod";
 var EIP712SignaturePayloadFieldsZod = z20.object({
@@ -1819,14 +2791,14 @@ var EIP712SignaturePayloadFieldsZod = z20.object({
 });
 var EIP712SignaturePayloadSchema = "network.xyo.chains.ethereum.eip712.signature";
 var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema);
-var asEIP712SignaturePayload = AsObjectFactory2.create(isEIP712SignaturePayload);
+var asEIP712SignaturePayload = AsObjectFactory3.create(isEIP712SignaturePayload);
 
 // src/eip-712/sign.ts
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
 var signEIP712Message = /* @__PURE__ */ __name(async (signer, data) => {
   const { domain, types, values } = data;
   const signature = await signer.signTypedData(domain, types, values);
-  const hash = await PayloadBuilder9.hash(data);
+  const hash = await PayloadBuilder12.hash(data);
   const address = await signer.getAddress();
   return {
     address,
@@ -1837,22 +2809,22 @@ var signEIP712Message = /* @__PURE__ */ __name(async (signer, data) => {
 }, "signEIP712Message");
 
 // src/eip-712/verify.ts
-import { asHash as asHash4, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { asHash as asHash4, isUndefined as isUndefined4 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
 import { verifyTypedData } from "ethers/hash";
 var verifyEIP712Message = /* @__PURE__ */ __name(async (data, sig) => {
   const { address, signature, hash } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash4(hash);
-  if (isUndefined3(signedHash) || signedHash !== await PayloadBuilder10.hash(data)) return false;
+  if (isUndefined4(signedHash) || signedHash !== await PayloadBuilder13.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 }, "verifyEIP712Message");
 
 // src/multipliers.ts
-import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL12(1343884111859145740576652n);
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = asAttoXL12(100000000000000000000000000n);
+import { asAttoXL1 as asAttoXL14 } from "@xyo-network/xl1-protocol";
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL14(1343884111859145740576652n);
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = asAttoXL14(100000000000000000000000000n);
 var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS = XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS + XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS;
 var RewardMultipliers = {
   [`0|${XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK}`]: [
@@ -1861,77 +2833,6 @@ var RewardMultipliers = {
   ]
 };
 
-// src/payloads/AddressPairPayload.ts
-import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
-var AddressPairSchema = "network.xyo.address.pair";
-var isAddressPairPayload = isPayloadOfSchemaType(AddressPairSchema);
-var asAddressPairPayload = AsObjectFactory3.create(isAddressPairPayload);
-var asOptionalAddressPairPayload = AsObjectFactory3.createOptional(isAddressPairPayload);
-
-// src/payloads/netBalancesForPayloads.ts
-import { hexToBigInt, toAddress as toAddress4 } from "@xylabs/sdk-js";
-import { span } from "@xylabs/sdk-js";
-import { isTransfer } from "@xyo-network/xl1-protocol";
-var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
-  return span("netBalancesForPayloads", () => {
-    const balances = {};
-    for (const payload of payloads) {
-      if (isTransfer(payload)) {
-        const { from } = payload;
-        for (let [address, amount] of Object.entries(payload.transfers)) {
-          balances[toAddress4(address)] = (balances[toAddress4(address)] ?? 0n) + hexToBigInt(amount);
-          balances[toAddress4(from)] = (balances[toAddress4(from)] ?? 0n) - hexToBigInt(amount);
-        }
-      }
-    }
-    return balances;
-  });
-}, "netBalancesForPayloads");
-
-// src/payloads/netSchemasForPayloads.ts
-import { hexToBigInt as hexToBigInt2, toAddress as toAddress5 } from "@xylabs/sdk-js";
-import { span as span2 } from "@xylabs/sdk-js";
-import { isTransfer as isTransfer2 } from "@xyo-network/xl1-protocol";
-var netSchemasForPayloads = /* @__PURE__ */ __name((payloads) => {
-  return span2("netSchemasForPayloads", () => {
-    const balances = {};
-    for (const payload of payloads) {
-      if (isTransfer2(payload)) {
-        const { from } = payload;
-        for (let [address, amount] of Object.entries(payload.transfers)) {
-          balances[toAddress5(address)] = (balances[toAddress5(address)] ?? 0n) + hexToBigInt2(amount);
-          balances[toAddress5(from)] = (balances[toAddress5(from)] ?? 0n) - hexToBigInt2(amount);
-        }
-      }
-    }
-    return balances;
-  });
-}, "netSchemasForPayloads");
-
-// src/payloads/netTransfersForPayloads.ts
-import { hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
-import { span as span3 } from "@xylabs/sdk-js";
-import { isTransfer as isTransfer3 } from "@xyo-network/xl1-protocol";
-function netTransfersForPayloads(payloads) {
-  return span3("netTransfersForPayloads", () => {
-    const transfers = {};
-    for (const payload of payloads) {
-      if (isTransfer3(payload)) {
-        const { from } = payload;
-        transfers[from] = transfers[from] ?? {};
-        for (let [to, amount] of Object.entries(payload.transfers)) {
-          transfers[to] = transfers[to] ?? {};
-          transfers[to][from] = (transfers[to][from] ?? 0n) + hexToBigInt3(amount);
-          transfers[from][to] = (transfers[from][to] ?? 0n) - hexToBigInt3(amount);
-        }
-      }
-    }
-    return transfers;
-  });
-}
-__name(netTransfersForPayloads, "netTransfersForPayloads");
-
 // src/provider/DataLake.ts
 var DataLakeViewerMoniker = "DataLakeViewer";
 var DataLakeRunnerMoniker = "DataLakeRunner";
@@ -1957,6 +2858,18 @@ var NetworkStakeStepRewardsViewerMoniker = "NetworkStakeStepRewardsViewer";
 // src/provider/viewer/XyoViewer.ts
 var XyoViewerMoniker = "XyoViewer";
 
+// src/provider/XyoConnection.ts
+var XyoConnectionMoniker = "XyoConnection";
+
+// src/provider/XyoRunner.ts
+var XyoRunnerMoniker = "XyoRunner";
+
+// src/runners/Block.ts
+var BlockRunnerMoniker = "BlockRunner";
+
+// src/runners/Mempool.ts
+var MempoolRunnerMoniker = "MempoolRunner";
+
 // src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts
 import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
 import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isStorageMeta } from "@xyo-network/payload-model";
@@ -1969,7 +2882,7 @@ var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value)
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory4.create(isChainIndexingServiceStateWithStorageMeta);
 
 // src/SignedBigInt.ts
-import { hexToBigInt as hexToBigInt4, toHex as toHex4 } from "@xylabs/sdk-js";
+import { hexToBigInt as hexToBigInt5, toHex as toHex5 } from "@xylabs/sdk-js";
 import { isObject } from "@xylabs/sdk-js";
 var isNegativeBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "negative" in value && typeof value.negative === "string";
@@ -1979,24 +2892,24 @@ var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
 }, "isPositiveBigInt");
 var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
-    return -hexToBigInt4(value.negative);
+    return -hexToBigInt5(value.negative);
   } else if (isPositiveBigInt(value)) {
-    return hexToBigInt4(value.positive);
+    return hexToBigInt5(value.positive);
   } else {
     throw new Error("Invalid balance type");
   }
 }, "parseSignedBigInt");
 var toSignedBigInt = /* @__PURE__ */ __name((value) => {
   return value < 0n ? {
-    negative: toHex4(-value)
+    negative: toHex5(-value)
   } : {
-    positive: toHex4(value)
+    positive: toHex5(value)
   };
 }, "toSignedBigInt");
 var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
     return {
-      positive: toHex4(0n)
+      positive: toHex5(0n)
     };
   }
   if (isPositiveBigInt(value)) {
@@ -2006,15 +2919,15 @@ var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
   }
   if (typeof value === "bigint") {
     return {
-      positive: toHex4(value)
+      positive: toHex5(value)
     };
   }
   throw new Error("Invalid value for positive big int");
 }, "toPositiveBigInt");
 
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
-import { asHash as asHash5, assertEx as assertEx16, exists, isDefined as isDefined11, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
-import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange5, AttoXL1 as AttoXL12, StepSizes as StepSizes9, TransferSchema } from "@xyo-network/xl1-protocol";
+import { asHash as asHash5, assertEx as assertEx23, exists as exists3, isDefined as isDefined13, spanRootAsync as spanRootAsync4, ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange7, AttoXL1 as AttoXL12, StepSizes as StepSizes11, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
 
 // src/summary/model/BalancesStepSummary.ts
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
@@ -2053,10 +2966,10 @@ var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
 var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersStepSummaryWithStorageMeta);
 
 // src/summary/primitives/balances/balancesStepSummaryFromRange.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/payload-builder";
 import { isAnyPayload } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
+import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
 async function balancesStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
@@ -2076,8 +2989,8 @@ async function balancesStepSummaryFromRange(context, range) {
       balances
     };
   } else {
-    const step = StepSizes6.indexOf(frameSize);
-    assertEx13(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes6.join(", ")}`);
+    const step = StepSizes8.indexOf(frameSize);
+    assertEx20(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
     const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
@@ -2109,27 +3022,29 @@ async function balancesStepSummaryFromRange(context, range) {
       }
     }
   }
-  const finalResult = await PayloadBuilder11.addStorageMeta(result);
+  const finalResult = await PayloadBuilder14.addStorageMeta(result);
   return finalResult;
 }
 __name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
 
 // src/summary/primitives/balances/balancesSummary.ts
-import { asAddress as asAddress3, isDefined as isDefined8, spanRootAsync } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockNumber as asXL1BlockNumber2, asXL1BlockRange as asXL1BlockRange2 } from "@xyo-network/xl1-protocol";
-async function balancesSummary(context) {
+import { asAddress as asAddress3, spanRootAsync } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockRange as asXL1BlockRange4 } from "@xyo-network/xl1-protocol";
+async function balancesSummary(context, config) {
   return await spanRootAsync("balancesSummary", async () => {
-    const [headHash] = await context.head();
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
     const headResult = await context.store.chainMap.get(headHash);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult, () => `Head block not found for hash: ${headHash}`);
-    const rangeStart = asXL1BlockNumber2(isDefined8(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange2([
-      rangeStart,
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange4([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4(range, {
       name: "balancesSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
+    const summaries = await Promise.all(ranges.map((range2) => balancesStepSummaryFromRange(context, range2)));
     const balances = {};
     for (let summary of summaries) {
       for (const [address, balance] of Object.entries(summary.balances)) {
@@ -2139,22 +3054,21 @@ async function balancesSummary(context) {
     }
     return [
       balances,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
 __name(balancesSummary, "balancesSummary");
 
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx21 } from "@xylabs/sdk-js";
 import { isBoundWitness } from "@xyo-network/boundwitness-model";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/payload-builder";
 import { isAnyPayload as isAnyPayload2, isHashMeta } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
+import { StepSizes as StepSizes9 } from "@xyo-network/xl1-protocol";
 async function schemasStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
@@ -2181,8 +3095,8 @@ async function schemasStepSummaryFromRange(context, range) {
       schemas
     };
   } else {
-    const step = StepSizes7.indexOf(frameSize);
-    assertEx14(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes7.join(", ")}`);
+    const step = StepSizes9.indexOf(frameSize);
+    assertEx21(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
     const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload2(summaryResult)) {
       result = summaryResult;
@@ -2210,26 +3124,28 @@ async function schemasStepSummaryFromRange(context, range) {
       }
     }
   }
-  return await PayloadBuilder12.addHashMeta(result);
+  return await PayloadBuilder15.addHashMeta(result);
 }
 __name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
 
 // src/summary/primitives/schemas/schemasSummary.ts
-import { isDefined as isDefined9, spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol";
-async function schemasSummary(context) {
+import { spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockRange as asXL1BlockRange5 } from "@xyo-network/xl1-protocol";
+async function schemasSummary(context, config) {
   return await spanRootAsync2("schemasSummary", async () => {
-    const [headHash] = await context.head();
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
     const headResult = await context.store.chainMap.get(headHash);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${headHash}`);
-    const rangeStart = asXL1BlockNumber3(isDefined9(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange3([
-      rangeStart,
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange5([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange5(range, {
       name: "schemasSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => schemasStepSummaryFromRange(context, range)));
+    const summaries = await Promise.all(ranges.map((range2) => schemasStepSummaryFromRange(context, range2)));
     const results = {};
     for (let summary of summaries) {
       for (const [schema, count] of Object.entries(summary.schemas)) {
@@ -2238,38 +3154,39 @@ async function schemasSummary(context) {
     }
     return [
       results,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
 __name(schemasSummary, "schemasSummary");
 
 // src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx15 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx22 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/payload-builder";
 import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
+import { StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol";
 
 // src/summary/primitives/transfers/transfersSummary.ts
-import { asAddress as asAddress4, isDefined as isDefined10, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber4, asXL1BlockRange as asXL1BlockRange4 } from "@xyo-network/xl1-protocol";
-async function transfersSummary(transferContext) {
+import { asAddress as asAddress4, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockRange as asXL1BlockRange6 } from "@xyo-network/xl1-protocol";
+async function transfersSummary(context, config) {
   return await spanRootAsync3("transferSummary", async () => {
-    const [headHash] = await transferContext.head();
-    const headResult = await transferContext.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${transferContext.head}`);
-    const rangeStart = asXL1BlockNumber4(isDefined10(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4([
-      rangeStart,
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
+    const headResult = await context.store.chainMap.get(headHash);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${headHash}`);
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange6([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange6(range, {
       name: "transfersSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
+    const summaries = await Promise.all(ranges.map((range2) => transfersStepSummaryFromRange(context, range2)));
     const transfers = {};
     for (let summary of summaries) {
       for (const [from, toMap] of Object.entries(summary.transfers)) {
@@ -2283,11 +3200,10 @@ async function transfersSummary(transferContext) {
     }
     return [
       transfers,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
@@ -2320,8 +3236,8 @@ async function transfersStepSummaryFromRange(context, range) {
       transfers
     };
   } else {
-    const step = StepSizes8.indexOf(frameSize);
-    assertEx15(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
+    const step = StepSizes10.indexOf(frameSize);
+    assertEx22(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
     const key = transfersSummaryKey(frameHeadHash, frameSize);
     const summaryResult = await context.summaryMap.get(key);
     if (isAnyPayload3(summaryResult)) {
@@ -2360,12 +3276,13 @@ async function transfersStepSummaryFromRange(context, range) {
       }
     }
   }
-  const finalResult = await PayloadBuilder13.addStorageMeta(result);
+  const finalResult = await PayloadBuilder16.addStorageMeta(result);
   return finalResult;
 }
 __name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
 
 // src/viewers/AccountBalance.ts
+import { zodIsFactory as zodIsFactory2 } from "@xylabs/zod";
 import { WithHashMetaZod } from "@xyo-network/payload-model";
 import { TransferZod } from "@xyo-network/xl1-protocol";
 import { BlockBoundWitnessZod, TransactionBoundWitnessZod } from "@xyo-network/xl1-protocol";
@@ -2375,6 +3292,10 @@ var AccountBalanceHistoryItemZod = z21.tuple([
   WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
   WithHashMetaZod(TransferZod)
 ]);
+var AccountBalanceQualificationZod = ChainQualificationZod;
+var isAccountBalanceQualification = zodIsFactory2(AccountBalanceQualificationZod);
+var AccountBalanceConfigZod = ChainQualifiedConfigZod;
+var isAccountBalanceCOnfig = zodIsFactory2(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/viewers/Block.ts
@@ -2383,8 +3304,23 @@ var BlockViewerMoniker = "BlockViewer";
 // src/viewers/BlockReward.ts
 var BlockRewardViewerMoniker = "BlockRewardViewer";
 
-// src/viewers/Chain.ts
-var ChainViewerMoniker = "ChainViewer";
+// src/viewers/BlockValidation.ts
+import { zodIsFactory as zodIsFactory3 } from "@xylabs/zod";
+import z22 from "zod";
+var BlockValidationQualificationZod = ChainQualificationZod;
+var isBlockValidationQualification = zodIsFactory3(BlockValidationQualificationZod);
+var BlockValidationConfigFieldsZod = z22.object({
+  value: z22.boolean().optional(),
+  state: z22.boolean().optional()
+});
+var BlockValidationConfigZod = z22.union([
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
+  BlockValidationConfigFieldsZod,
+  z22.object({})
+]);
+var isBlockValidationConfig = zodIsFactory3(BlockValidationConfigZod);
+var BlockValidationViewerMoniker = "BlockValidationViewer";
 
 // src/viewers/ChainContract.ts
 var ChainContractViewerMoniker = "ChainContractViewer";
@@ -2395,15 +3331,15 @@ var ChainStakeViewerMoniker = "ChainStakeViewer";
 // src/viewers/Mempool.ts
 import { HashZod as HashZod3 } from "@xylabs/sdk-js";
 import { XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
-import z22 from "zod";
-var PendingTransactionsOptionsZod = z22.object({
+import z23 from "zod";
+var PendingTransactionsOptionsZod = z23.object({
   cursor: HashZod3.optional(),
-  limit: z22.number().int().positive().optional(),
+  limit: z23.number().int().positive().optional(),
   window: XL1BlockRangeZod2.optional()
 });
-var PendingBlocksOptionsZod = z22.object({
+var PendingBlocksOptionsZod = z23.object({
   cursor: HashZod3.optional(),
-  limit: z22.number().int().positive().optional(),
+  limit: z23.number().int().positive().optional(),
   window: XL1BlockRangeZod2.optional()
 });
 var MempoolViewerMoniker = "MempoolViewer";
@@ -2435,6 +3371,14 @@ var StepViewerMoniker = "StepViewer";
 // src/viewers/TimeSync.ts
 var TimeSyncViewerMoniker = "TimeSyncViewer";
 
+// src/viewers/TransactionValidation.ts
+import { zodIsFactory as zodIsFactory4 } from "@xylabs/zod";
+var TransactionValidationQualificationZod = ChainQualificationZod;
+var isTransactionValidationQualification = zodIsFactory4(TransactionValidationQualificationZod);
+var TransactionValidationConfigZod = ChainQualifiedConfigZod;
+var isTransactionValidationConfig = zodIsFactory4(TransactionValidationConfigZod);
+var TransactionValidationViewerMoniker = "TransactionValidationViewer";
+
 // src/viewers/TransferBalance.ts
 var TransferBalanceViewerMoniker = "TransferBalanceViewer";
 
@@ -2455,47 +3399,47 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     AccountBalanceViewerMoniker
   ];
   moniker = _SimpleAccountBalanceViewer.defaultMoniker;
-  get blockViewer() {
-    return this.params.blockViewer;
+  _blockViewer;
+  get balanceSummaryContext() {
+    return this.params.balanceSummaryContext;
   }
-  get context() {
-    return this.params.context;
+  get blockViewer() {
+    return this._blockViewer;
   }
   get transfersSummaryContext() {
     return this.params.transfersSummaryContext;
   }
-  static async paramsHandler(params) {
-    assertEx16(params.blockViewer, () => "blockViewer is required");
-    assertEx16(params.context, () => "context is required");
-    assertEx16(params.transfersSummaryContext, () => "transfersSummaryContext is required");
-    return {
-      ...await super.paramsHandler(params)
-    };
+  static async paramsHandler(params = {}) {
+    assertEx23(params.transfersSummaryContext, () => "transfersSummaryContext is required");
+    assertEx23(params.balanceSummaryContext, () => "balanceSummaryContext is required");
+    return await super.paramsHandler({
+      ...params
+    });
   }
-  async accountBalance(address, headOrRange) {
+  async accountBalance(address, config) {
     const balances = await this.accountBalances([
       address
-    ], headOrRange);
+    ], config);
     return balances[address] ?? AttoXL12(0n);
   }
-  accountBalanceHistories(_addresses, _rangeOrHash) {
-    throw new Error("Method [accountBalanceHistories] not implemented.");
+  async accountBalanceHistories(addresses, config = {}) {
+    return (await this.qualifiedAccountBalanceHistories(addresses, config))[0];
   }
-  async accountBalanceHistory(address, headOrRange) {
-    const range = asRange(headOrRange);
-    const startingRange = asXL1BlockRange5(range ?? [
+  async accountBalanceHistory(address, config) {
+    const range = isChainQualifiedRangeConfig(config) ? config.range : void 0;
+    const startingRange = asXL1BlockRange7(range ?? [
       0,
       await this.blockViewer.currentBlockNumber()
     ], true);
     const blockNumbers = await this.distillTransferHistory(address, startingRange);
-    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists);
+    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
     const result = [];
     for (const block of blocks) {
-      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists);
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
       const transfers = transferIndexes.map((index) => {
         const hash = block[0].payload_hashes[index];
-        return assertEx16(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-      }).filter(exists).filter((t) => t.from === address || isDefined11(t.transfers[address]));
+        return assertEx23(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists3).filter((t) => t.from === address || isDefined13(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -2513,15 +3457,19 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     }
     return result;
   }
-  async accountBalances(address, _headOrRange) {
-    const [result] = await this.qualifiedAccountBalances(address, _headOrRange);
+  async accountBalances(address, config) {
+    const [result] = await this.qualifiedAccountBalances(address, config ?? {});
     return result;
   }
-  async qualifiedAccountBalanceHistories(addresses, headOrRange) {
-    const head = asHash5(headOrRange) ?? await this.blockViewer.currentBlockHash();
-    const range = asXL1BlockRange5(headOrRange) ?? asXL1BlockRange5([
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
+  async qualifiedAccountBalanceHistories(addresses, config) {
+    const head = isChainQualifiedHeadConfig(config) ? config.head : await this.blockViewer.currentBlockHash();
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange7([
       0,
-      assertEx16(await this.blockViewer.blockByHash(head), () => `Error: Could not find block with hash ${head}`)[0].block
+      assertEx23(await this.blockViewer.blockByHash(head), () => `Error: Could not find block with hash ${head}`)[0].block
     ]);
     const qualifiedEntries = await Promise.all(addresses.map(async (address) => [
       address,
@@ -2533,21 +3481,25 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
         history
       ];
     });
-    const qualifiedRange = qualifiedEntries[0][1][1];
-    const qualifiedHeadHash = qualifiedEntries[0][1][2];
-    for (const [_, [__, range2, headHash]] of qualifiedEntries) {
-      assertEx16(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
-      assertEx16(headHash === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
+    const qualifiedRange = qualifiedEntries[0][1][1].range;
+    const qualifiedHeadHash = qualifiedEntries[0][1][1].head;
+    for (const [_, [__, { range: range2, head: head2 }]] of qualifiedEntries) {
+      assertEx23(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
+      assertEx23(head2 === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
     }
     return [
       Object.fromEntries(entries),
-      qualifiedRange,
-      qualifiedHeadHash
+      {
+        range: qualifiedRange,
+        head: qualifiedHeadHash
+      }
     ];
   }
-  async qualifiedAccountBalances(address, _headOrRange) {
+  async qualifiedAccountBalances(address, config) {
     return await spanRootAsync4("qualifiedAccountsBalances", async () => {
-      const qualifiedSummary = await balancesSummary(this.context);
+      const qualifiedSummary = await balancesSummary({
+        ...this.balanceSummaryContext
+      }, config);
       const result = {};
       for (const addr of address) {
         const summaryBalance = qualifiedSummary[0][addr] ?? 0n;
@@ -2555,18 +3507,24 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
       }
       return [
         result,
-        qualifiedSummary[1],
-        qualifiedSummary[2]
+        qualifiedSummary[1]
       ];
     });
   }
+  async startHandler() {
+    await super.startHandler();
+    await Promise.all([
+      this.accountBalance(ZERO_ADDRESS),
+      this.accountBalanceHistory(ZERO_ADDRESS)
+    ]);
+  }
   async distillTransferHistory(address, range, max = 50) {
-    if (range[1] - range[0] <= StepSizes9[0] || max <= 1) {
+    if (range[1] - range[0] <= StepSizes11[0] || max <= 1) {
       return Array.from({
         length: range[1] - range[0] + 1
       }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber5(n, true));
     }
-    const frames = deepCalculateFramesFromRange(asXL1BlockRange5(range, true));
+    const frames = deepCalculateFramesFromRange(asXL1BlockRange7(range, true));
     const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
       return [
         frame,
@@ -2579,8 +3537,8 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     });
     const resultBlockNumbers = /* @__PURE__ */ new Set();
     for (const [frame] of sortedTransferSummaryPairs) {
-      if (frame[1] - frame[0] + 1 > StepSizes9[0]) {
-        const values = await this.distillTransferHistory(address, asXL1BlockRange5([
+      if (frame[1] - frame[0] + 1 > StepSizes11[0]) {
+        const values = await this.distillTransferHistory(address, asXL1BlockRange7([
           frame[0],
           frame[1] - 1
         ], true), max - resultBlockNumbers.size);
@@ -2604,20 +3562,20 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
   async qualifiedAccountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
     const headHash = asHash5(headOrRange);
-    const [head] = assertEx16(isDefined11(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
-    const startingRange = asXL1BlockRange5(range ?? [
+    const [head] = assertEx23(isDefined13(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+    const startingRange = asXL1BlockRange7(range ?? [
       0,
       head.block
     ], true);
     const blockNumbers = await this.distillTransferHistory(address, startingRange);
-    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists);
+    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
     const result = [];
     for (const block of blocks) {
-      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists);
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
       const transfers = transferIndexes.map((index) => {
         const hash = block[0].payload_hashes[index];
-        return assertEx16(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-      }).filter(exists).filter((t) => t.from === address || isDefined11(t.transfers[address]));
+        return assertEx23(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists3).filter((t) => t.from === address || isDefined13(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -2635,8 +3593,10 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     }
     return [
       result,
-      startingRange,
-      head._hash
+      {
+        range: startingRange,
+        head: head._hash
+      }
     ];
   }
 };
@@ -2645,7 +3605,7 @@ SimpleAccountBalanceViewer = _ts_decorate([
 ], SimpleAccountBalanceViewer);
 
 // src/simple/block/SimpleBlockViewer.ts
-import { assertEx as assertEx17, exists as exists2, isDefined as isDefined12, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx24, exists as exists4, isDefined as isDefined14, isUndefined as isUndefined5, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
 import { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber6 } from "@xyo-network/xl1-protocol";
 
 // src/utils/HydratedCache.ts
@@ -2679,12 +3639,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import * as z23 from "zod";
+import * as z24 from "zod";
 var isZodError = /* @__PURE__ */ __name((error) => {
-  return error instanceof z23.ZodError;
+  return error instanceof z24.ZodError;
 }, "isZodError");
 var prettifyZodError = /* @__PURE__ */ __name((error) => {
-  return z23.prettifyError(error);
+  return z24.prettifyError(error);
 }, "prettifyZodError");
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -2704,21 +3664,17 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
     BlockViewerMoniker
   ];
   moniker = _SimpleBlockViewer.defaultMoniker;
+  _store;
   _payloadCache;
   _signedHydratedBlockCache;
-  get context() {
-    return this.params.context;
-  }
   get finalizedArchivist() {
     return this.params.finalizedArchivist;
   }
   get hydratedBlockCache() {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
-    const chainMap = this.context.store.chainMap;
-    this._signedHydratedBlockCache = new HydratedCache(chainMap, async ({ chainMap: chainMap2 }, hash, maxDepth, minDepth) => {
-      const result = await hydrateBlock({
-        chainMap: chainMap2
-      }, hash, maxDepth, minDepth);
+    const chainMap = this.store.chainMap;
+    this._signedHydratedBlockCache = new HydratedCache(chainMap, async (store, hash, maxDepth, minDepth) => {
+      const result = await hydrateBlock(store, hash, maxDepth, minDepth);
       return asSignedHydratedBlockWithHashMeta(result, true);
     }, 200);
     return this._signedHydratedBlockCache;
@@ -2730,9 +3686,11 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
     });
     return this._payloadCache;
   }
+  get store() {
+    return this._store;
+  }
   static async paramsHandler(params) {
-    assertEx17(params.context, () => "context is required");
-    assertEx17(params.finalizedArchivist, () => "finalizedArchivist is required");
+    assertEx24(params.finalizedArchivist, () => "finalizedArchivist is required");
     return {
       ...await super.paramsHandler(params)
     };
@@ -2745,13 +3703,27 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async blockByNumber(blockNumber) {
     return await spanRootAsync5("blockByNumber", async () => {
-      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null;
+      const head = await this.getCurrentHead();
+      if (isUndefined5(head)) {
+        return null;
+      }
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber({
+        chainId: head.chain,
+        head: /* @__PURE__ */ __name(() => {
+          return [
+            head._hash,
+            head.block
+          ];
+        }, "head"),
+        store: this.store,
+        singletons: this.context.singletons
+      }, blockNumber)) ?? null;
     }, this.tracer);
   }
   async blocksByHash(hash, limit = 50) {
     return await spanRootAsync5("blocksByHash", async () => {
-      assertEx17(limit > 0, () => "limit must be greater than 0");
-      assertEx17(limit <= 100, () => "limit must be less than 100");
+      assertEx24(limit > 0, () => "limit must be greater than 0");
+      assertEx24(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -2765,8 +3737,8 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await spanRootAsync5("blocksByHash", async () => {
-      assertEx17(limit > 0, () => "limit must be greater than 0");
-      assertEx17(limit <= 100, () => "limit must be less than 100");
+      assertEx24(limit > 0, () => "limit must be greater than 0");
+      assertEx24(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByNumber(blockNumber);
       while (current && blocks.length < limit) {
@@ -2778,26 +3750,38 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
       return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
     }, this.tracer);
   }
+  async chainId(blockNumber = "latest") {
+    return await spanRootAsync5("chainId", async () => {
+      const block = assertEx24(blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber), () => `Could not find block for block number ${blockNumber}`);
+      return block[0].chain;
+    });
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._store = {
+      chainMap: readPayloadMapFromStore(this.params.finalizedArchivist)
+    };
+  }
   async currentBlock() {
     return await spanRootAsync5("currentBlock", async () => {
-      const currentHead = assertEx17(await this.getCurrentHead(), () => "Could not find most recent block");
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         console.log(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx17(block, () => "Could not find current block");
+      return assertEx24(block, () => "Could not find current block");
     }, this.tracer);
   }
   async currentBlockHash() {
     return await spanRootAsync5("currentBlockHash", async () => {
-      const currentHead = assertEx17(await this.getCurrentHead(), () => "Could not find most recent block");
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockHash]");
       return currentHead._hash;
     }, this.tracer);
   }
   async currentBlockNumber() {
     return await spanRootAsync5("currentBlockNumber", async () => {
-      const currentHead = assertEx17(await this.getCurrentHead(), () => "Could not find most recent block");
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockNumber]");
       return asXL1BlockNumber6(currentHead.block, {
         name: "currentBlockNumber"
       });
@@ -2811,7 +3795,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
       const [result] = await this.finalizedArchivist.get([
         hash
       ]);
-      if (isDefined12(result)) {
+      if (isDefined14(result)) {
         await this.payloadCache.set(hash, result);
       }
       return result ?? null;
@@ -2827,7 +3811,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
     const remainingPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
     return [
       ...cachedPayloads,
-      ...remainingPayloads.filter(exists2)
+      ...remainingPayloads.filter(exists4)
     ];
   }
   async getCurrentHead() {
@@ -2865,13 +3849,9 @@ SimpleBlockRewardViewer = _ts_decorate3([
   creatableProvider()
 ], SimpleBlockRewardViewer);
 
-// src/simple/chainStake/SimpleChainStakeViewer.ts
-import { asAddress as asAddress5, toAddress as toAddress6 } from "@xylabs/sdk-js";
-import { assertEx as assertEx18 } from "@xylabs/sdk-js";
-import { Account } from "@xyo-network/account";
-
-// src/simple/chainStakeEvents/SimpleChainStakeEventsViewer.ts
-import { isDefined as isDefined13 } from "@xylabs/sdk-js";
+// src/simple/blockValidation/SimpleBlockValidationViewer.ts
+import { exists as exists5 } from "@xylabs/sdk-js";
+import { asXL1BlockRange as asXL1BlockRange8 } from "@xyo-network/xl1-protocol";
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2879,88 +3859,103 @@ function _ts_decorate4(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate4, "_ts_decorate");
-var SimpleChainStakeEventsViewer = class _SimpleChainStakeEventsViewer extends AbstractCreatableProvider {
+var SimpleBlockValidationViewer = class _SimpleBlockValidationViewer extends AbstractCreatableProvider {
   static {
-    __name(this, "SimpleChainStakeEventsViewer");
+    __name(this, "SimpleBlockValidationViewer");
   }
-  static defaultMoniker = StakeEventsViewerMoniker;
+  static defaultMoniker = BlockValidationViewerMoniker;
   static monikers = [
-    StakeEventsViewerMoniker
+    BlockValidationViewerMoniker
   ];
-  moniker = _SimpleChainStakeEventsViewer.defaultMoniker;
-  get positions() {
-    return this.params.positions;
-  }
-  positionCount(range) {
-    return this.positionsFromRange(range).length;
+  moniker = _SimpleBlockValidationViewer.defaultMoniker;
+  _accountBalanceViewer;
+  _blockViewer;
+  _uncleWindowedChainCache = null;
+  get blockViewer() {
+    return this._blockViewer;
   }
-  stakeEvents(range, { name } = {}) {
-    const positions = this.positionsFromRange(range);
-    const events = this.eventsFromPositions(positions);
-    if (isDefined13(name)) {
-      return events.filter((event) => event.name === name);
-    }
-    return events;
+  get maxUncleWindowSize() {
+    return this.params.maxUncleWindowSize;
   }
-  async startHandler() {
-    await super.startHandler();
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      maxUncleWindowSize: params.maxUncleWindowSize ?? 100
+    };
   }
-  eventsFromPositions(positions) {
-    const events = positions.map((position) => {
-      const events2 = [
-        {
-          name: "StakeAdded",
-          time: position.addBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id
-          }
-        }
-      ];
-      if (position.removeBlock !== 0) {
-        events2.push({
-          name: "StakeRemoved",
-          time: position.removeBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id
-          }
-        });
-      }
-      if (position.withdrawBlock !== 0) {
-        events2.push({
-          name: "StakeWithdrawn",
-          time: position.withdrawBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id
-          }
-        });
+  async createHandler() {
+    await super.createHandler();
+    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
+  async qualifiedValidateBlock(block, config) {
+    return await this.qualifiedValidateBlocks([
+      block
+    ], config);
+  }
+  async qualifiedValidateBlocks(blocks, config) {
+    const { value, state } = config ?? {
+      shape: true,
+      links: true,
+      state: true
+    };
+    const [headBlock] = await this.blockViewer.currentBlock();
+    const chainId = headBlock.chain;
+    const validateValue = value ? this.doValidateValue.bind(this) : void 0;
+    const validateState = state ? this.doValidateState.bind(this) : void 0;
+    return [
+      (await Promise.all([
+        validateValue?.(blocks, chainId),
+        validateState?.(blocks, chainId)
+      ].filter(exists5))).flat(),
+      {
+        head: headBlock._hash,
+        range: asXL1BlockRange8([
+          0,
+          headBlock.block
+        ], true)
       }
-      return events2;
-    });
-    return events.flat();
+    ];
   }
-  positionsFromRange(range) {
-    const startBlock = range[0];
-    const endBlock = range[1] === "latest" ? Number.MAX_SAFE_INTEGER : range[1];
-    const filteredPositions = this.positions.filter((position) => {
-      return position.addBlock <= endBlock && (position.removeBlock === 0 || position.removeBlock >= startBlock);
-    });
-    return filteredPositions;
+  async validateBlock(block, config) {
+    return await this.validateBlocks([
+      block
+    ], config);
+  }
+  async validateBlocks(blocks, config) {
+    return (await this.qualifiedValidateBlocks(blocks, config))[0];
+  }
+  async doValidateState(blocks, chainId) {
+    const windowedUncleChain = await this.updateWindowedChainCache();
+    const uncles = findUncles(this.context, windowedUncleChain, blocks);
+    if (uncles.length !== 1) {
+      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}]`);
+    }
+    return (await Promise.all(uncles[0].map(async (block) => {
+      return await this.params.state(block, chainId, {
+        accountBalance: this._accountBalanceViewer
+      });
+    }))).flat();
+  }
+  async doValidateValue(blocks, chainId) {
+    return (await Promise.all(blocks.map(async (block) => {
+      return await this.params.value(block, chainId);
+    }))).flat();
+  }
+  async updateWindowedChainCache() {
+    this._uncleWindowedChainCache = await getWindowedChain(this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? []);
+    return [
+      ...this._uncleWindowedChainCache
+    ];
   }
 };
-SimpleChainStakeEventsViewer = _ts_decorate4([
+SimpleBlockValidationViewer = _ts_decorate4([
   creatableProvider()
-], SimpleChainStakeEventsViewer);
+], SimpleBlockValidationViewer);
 
-// src/simple/chainStake/SimpleChainStakeViewer.ts
+// src/simple/chainStake/SimpleStakeViewer.ts
+import { asAddress as asAddress5, toAddress as toAddress9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx25 } from "@xylabs/sdk-js";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2968,20 +3963,16 @@ function _ts_decorate5(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate5, "_ts_decorate");
-var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreatableProvider {
+var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvider {
   static {
-    __name(this, "SimpleChainStakeViewer");
+    __name(this, "SimpleStakeViewer");
   }
   static defaultMoniker = StakeViewerMoniker;
   static monikers = [
     StakeViewerMoniker
   ];
-  moniker = _SimpleChainStakeViewer.defaultMoniker;
-  _chainId;
+  moniker = _SimpleStakeViewer.defaultMoniker;
   _chainStakeEventsViewer;
-  get chainId() {
-    return assertEx18(this._chainId, () => "Chain ID not set");
-  }
   get chainMap() {
     return this.params.chainMap;
   }
@@ -2989,13 +3980,13 @@ var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreat
     return this.params.minWithdrawalBlocks ?? 10;
   }
   get rewardsContract() {
-    return toAddress6(toAddress6(1n));
+    return toAddress9(toAddress9(1n));
   }
   get stakeEvents() {
-    return assertEx18(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx25(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
-    return toAddress6("0x000000000000000000000000000011");
+    return toAddress9("0x000000000000000000000000000011");
   }
   get positions() {
     return this.params.positions;
@@ -3027,6 +4018,10 @@ var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreat
     }
     return active;
   }
+  async createHandler() {
+    await super.createHandler();
+    this._chainStakeEventsViewer = assertEx25(await this.locateAndCreate(StakeEventsViewerMoniker), () => "Failed to create StakeEventsViewer");
+  }
   pending() {
     let pending = 0n;
     for (const position of this.positions) {
@@ -3046,7 +4041,7 @@ var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreat
     return pending;
   }
   stakeById(id) {
-    return assertEx18(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx25(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
     return this.positions.filter((s) => asAddress5(s.staker) === asAddress5(staker))[slot];
@@ -3083,17 +4078,10 @@ var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreat
     }
     return withdrawn;
   }
-  async startHandler() {
-    await super.startHandler();
-    this._chainId = this.params.chainId ?? (await Account.random()).address;
-    this._chainStakeEventsViewer = await SimpleChainStakeEventsViewer.create({
-      positions: this.positions
-    });
-  }
 };
-SimpleChainStakeViewer = _ts_decorate5([
+SimpleStakeViewer = _ts_decorate5([
   creatableProvider()
-], SimpleChainStakeViewer);
+], SimpleStakeViewer);
 
 // src/simple/client/SimpleXyoClient.ts
 var SimpleXyoClient = class {
@@ -3123,21 +4111,21 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
   get map() {
     return this.params.map;
   }
-  // async get(hash: Hash): Promise<DataLakeData | undefined> {
-  //   const result = await this.map.get(hash)
-  //   return this.isAllowed(result) ? result : undefined
-  // }
-  // async getMany(hashes: Hash[]): Promise<DataLakeData[]> {
-  //   const result = await this.map.getMany(hashes)
-  //   return result.filter(data => this.isAllowed(data))
-  // }
-  // async has(hash: Hash): Promise<boolean> {
-  //   const value = await this.get(hash)
-  //   if (isAnyPayload(value)) {
-  //     return this.isAllowed(value)
-  //   }
-  //   return value !== undefined
-  // }
+  async get(hash) {
+    const result = await this.map.get(hash);
+    return this.isAllowed(result) ? result : void 0;
+  }
+  async getMany(hashes) {
+    const result = await this.map.getMany(hashes);
+    return result.filter((data) => this.isAllowed(data));
+  }
+  async has(hash) {
+    const value = await this.get(hash);
+    if (isAnyPayload4(value)) {
+      return this.isAllowed(value);
+    }
+    return value !== void 0;
+  }
   isAllowed(value) {
     if (isAnyPayload4(value)) {
       return this.isAllowedSchema(value.schema);
@@ -3193,7 +4181,6 @@ SimpleDataLakeRunner = _ts_decorate6([
 ], SimpleDataLakeRunner);
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
-import { isAnyPayload as isAnyPayload5 } from "@xyo-network/payload-model";
 function _ts_decorate7(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -3210,21 +4197,6 @@ var SimpleDataLakeViewer = class _SimpleDataLakeViewer extends AbstractSimpleDat
     DataLakeViewerMoniker
   ];
   moniker = _SimpleDataLakeViewer.defaultMoniker;
-  async get(hash) {
-    const result = await this.map.get(hash);
-    return this.isAllowed(result) ? result : void 0;
-  }
-  async getMany(hashes) {
-    const result = await this.map.getMany(hashes);
-    return result.filter((data) => this.isAllowed(data));
-  }
-  async has(hash) {
-    const value = await this.get(hash);
-    if (isAnyPayload5(value)) {
-      return this.isAllowed(value);
-    }
-    return value !== void 0;
-  }
 };
 SimpleDataLakeViewer = _ts_decorate7([
   creatableProvider()
@@ -3256,9 +4228,9 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-import { assertEx as assertEx19, BigIntToJsonZod, isDefined as isDefined14 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/payload-builder";
-import { asXL1BlockNumber as asXL1BlockNumber7, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx26, BigIntToJsonZod, isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/payload-builder";
+import { asXL1BlockNumber as asXL1BlockNumber7, TransferSchema as TransferSchema3 } from "@xyo-network/xl1-protocol";
 var SimpleXyoGatewayRunner = class {
   static {
     __name(this, "SimpleXyoGatewayRunner");
@@ -3287,18 +4259,18 @@ var SimpleXyoGatewayRunner = class {
     return this._dataLakes.length - 1;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx19(this.connectionInstance.viewer, () => "No viewer available on connection");
+    const viewer = assertEx26(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined14(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber7(isDefined14(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber7(isDefined14(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedChainId = isDefined15(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber7(isDefined15(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber7(isDefined15(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await (await this.signer()).address(), fees);
     return await this.addTransactionToChain(tx);
   }
   async addTransactionToChain(tx) {
     const connection = this.connectionInstance;
     const signer = this.signerInstance;
-    const runner = assertEx19(connection.runner, () => "No runner available on connection");
+    const runner = assertEx26(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
@@ -3310,7 +4282,7 @@ var SimpleXyoGatewayRunner = class {
     ];
   }
   async confirmSubmittedTransaction(txHash, options) {
-    return await confirmSubmittedTransaction(assertEx19(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
+    return await confirmSubmittedTransaction(assertEx26(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
   }
   /** @deprecated use connectionInstance instead */
   connection() {
@@ -3330,8 +4302,8 @@ var SimpleXyoGatewayRunner = class {
       address,
       BigIntToJsonZod.parse(amount)
     ]));
-    const transfer = new PayloadBuilder14({
-      schema: TransferSchema2
+    const transfer = new PayloadBuilder17({
+      schema: TransferSchema3
     }).fields({
       from,
       transfers: hexTransfers,
@@ -3356,8 +4328,7 @@ var SimpleXyoGatewayRunner = class {
 };
 
 // src/simple/mempool/SimpleMempoolRunner.ts
-import { AbstractCreatable as AbstractCreatable2, creatable } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/payload-builder";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -3365,10 +4336,15 @@ function _ts_decorate8(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate8, "_ts_decorate");
-var SimpleMempoolRunner = class extends AbstractCreatable2 {
+var SimpleMempoolRunner = class _SimpleMempoolRunner extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleMempoolRunner");
   }
+  static defaultMoniker = MempoolRunnerMoniker;
+  static monikers = [
+    MempoolRunnerMoniker
+  ];
+  moniker = _SimpleMempoolRunner.defaultMoniker;
   get pendingBlocksArchivist() {
     return this.params.pendingBlocksArchivist;
   }
@@ -3378,8 +4354,8 @@ var SimpleMempoolRunner = class extends AbstractCreatable2 {
   async submitBlocks(blocks) {
     const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
       return hydratedBlockToPayloadBundle([
-        await PayloadBuilder15.addHashMeta(bw),
-        await PayloadBuilder15.addHashMeta(payloads)
+        await PayloadBuilder18.addHashMeta(bw),
+        await PayloadBuilder18.addHashMeta(payloads)
       ]);
     }));
     const inserted = await this.pendingBlocksArchivist.insert(bundles);
@@ -3388,20 +4364,20 @@ var SimpleMempoolRunner = class extends AbstractCreatable2 {
   async submitTransactions(transactions) {
     const bundles = await Promise.all(transactions.map(async ([tx, payloads]) => {
       return hydratedTransactionToPayloadBundle([
-        await PayloadBuilder15.addHashMeta(tx),
-        await PayloadBuilder15.addHashMeta(payloads)
+        await PayloadBuilder18.addHashMeta(tx),
+        await PayloadBuilder18.addHashMeta(payloads)
       ]);
     }));
-    const inserted = await this.pendingBlocksArchivist.insert(bundles);
+    const inserted = await this.pendingTransactionsArchivist.insert(bundles);
     return inserted.map((p) => p._hash);
   }
 };
 SimpleMempoolRunner = _ts_decorate8([
-  creatable()
+  creatableProvider()
 ], SimpleMempoolRunner);
 
 // src/simple/mempool/SimpleMempoolViewer.ts
-import { creatable as creatable2, exists as exists3, isDefined as isDefined15, isHash } from "@xylabs/sdk-js";
+import { creatable, exists as exists6, isDefined as isDefined16, isHash } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle } from "@xyo-network/payload-model";
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -3431,7 +4407,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingBlocksArchivist.get([
         providedCursor
       ]);
-      if (isDefined15(p)) {
+      if (isDefined16(p)) {
         cursor = p._sequence;
       }
     }
@@ -3441,7 +4417,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       cursor
     });
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
-    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists3);
+    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists6);
   }
   async pendingTransactions({ cursor: providedCursor } = {}) {
     let cursor = void 0;
@@ -3449,25 +4425,30 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingTransactionsArchivist.get([
         providedCursor
       ]);
-      if (isDefined15(p)) {
+      if (isDefined16(p)) {
         cursor = p._sequence;
       }
     }
+    this.logger?.info(`Fetching pending transactions from cursor: ${cursor}`);
     const bundles = await this.pendingTransactionsArchivist.next({
       order: "asc",
       limit: 100,
       cursor
     });
+    this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`);
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
-    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedTransaction(bundle3)))).filter(exists3);
+    this.logger?.info(`Filtered pending transactions: ${JSON.stringify(bundles, null, 2)} filteredBundles`);
+    const result = (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedTransaction(bundle3)))).filter(exists6);
+    this.logger?.info(`Converted pending transactions: ${JSON.stringify(result, null, 2)} results`);
+    return result;
   }
 };
 SimpleMempoolViewer = _ts_decorate9([
-  creatable2()
+  creatable()
 ], SimpleMempoolViewer);
 
 // src/simple/network/SimpleXyoNetwork.ts
-import { isUndefined as isUndefined4 } from "@xylabs/sdk-js";
+import { isUndefined as isUndefined6 } from "@xylabs/sdk-js";
 import { isNetworkStatus } from "@xyo-network/xl1-protocol";
 import axios from "axios";
 
@@ -3514,7 +4495,7 @@ var SimpleXyoNetwork = class {
   }
   async status() {
     const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined4(statusNetwork)) {
+    if (isUndefined6(statusNetwork)) {
       throw new Error(`Unknown status network ID: ${this._networkId}`);
     }
     return await this.makeRequest(statusNetwork.statusUrl);
@@ -3539,7 +4520,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { assertEx as assertEx27 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -3551,7 +4532,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx20(this._store, () => "Store must be defined to get permissions");
+    return assertEx27(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -3609,7 +4590,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx21 } from "@xylabs/sdk-js";
+import { assertEx as assertEx28 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -3620,7 +4601,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx21(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx28(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -3633,33 +4614,48 @@ var MemoryPermissionsStore = class {
 };
 
 // src/simple/runner/SimpleXyoRunner.ts
-import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/payload-builder";
-var SimpleXyoRunner = class {
+import { assertEx as assertEx29 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder19 } from "@xyo-network/payload-builder";
+var SimpleXyoRunner = class _SimpleXyoRunner extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleXyoRunner");
   }
-  _mempoolArchivist;
-  constructor(mempoolArchivist) {
-    this._mempoolArchivist = mempoolArchivist;
+  static defaultMoniker = XyoRunnerMoniker;
+  static monikers = [
+    XyoRunnerMoniker
+  ];
+  moniker = _SimpleXyoRunner.defaultMoniker;
+  _mempoolRunner;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      pendingTransactionsArchivist: assertEx29(params?.pendingTransactionsArchivist, () => "A pendingTransactionsArchivist is required to create a SimpleXyoRunner")
+    };
   }
   async broadcastTransaction(transaction) {
-    const archivist = await this.getMempoolArchivist();
-    await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder16.hash(transaction[0]);
-  }
-  async getMempoolArchivist() {
-    if (!this._mempoolArchivist) {
-      this._mempoolArchivist = await MemoryArchivist.create({
-        account: "random"
-      });
-    }
-    return this._mempoolArchivist;
+    const archivist = this.params.pendingTransactionsArchivist;
+    const bundle3 = hydratedTransactionToPayloadBundle(transaction);
+    await archivist.insert([
+      bundle3
+    ]);
+    await this.mempool.submitTransactions([
+      transaction
+    ]);
+    const hash = await PayloadBuilder19.hash(transaction[0]);
+    this.logger?.info(`Broadcasted transaction with hash ${hash}`);
+    return hash;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._mempoolRunner = await this.locator.getInstance(MempoolRunnerMoniker);
   }
 };
 
 // src/simple/signer/SimpleXyoSigner.ts
-import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/payload-builder";
 import { SignedHydratedTransactionWithHashMetaZod } from "@xyo-network/xl1-protocol";
 var SimpleXyoSigner = class {
   static {
@@ -3680,15 +4676,105 @@ var SimpleXyoSigner = class {
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
     return SignedHydratedTransactionWithHashMetaZod.parse([
-      await PayloadBuilder17.addStorageMeta(txBW),
-      await PayloadBuilder17.addStorageMeta(tx[1])
+      await PayloadBuilder20.addStorageMeta(txBW),
+      await PayloadBuilder20.addStorageMeta(tx[1])
     ]);
   }
 };
 
+// src/simple/stakeEvents/SimpleStakeEventsViewer.ts
+import { isDefined as isDefined17 } from "@xylabs/sdk-js";
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+var SimpleStakeEventsViewer = class _SimpleStakeEventsViewer extends AbstractCreatableProvider {
+  static {
+    __name(this, "SimpleStakeEventsViewer");
+  }
+  static defaultMoniker = StakeEventsViewerMoniker;
+  static monikers = [
+    StakeEventsViewerMoniker
+  ];
+  moniker = _SimpleStakeEventsViewer.defaultMoniker;
+  get positions() {
+    return this.params.positions;
+  }
+  positionCount(range) {
+    return this.positionsFromRange(range).length;
+  }
+  stakeEvents(range, { name } = {}) {
+    const positions = this.positionsFromRange(range);
+    const events = this.eventsFromPositions(positions);
+    if (isDefined17(name)) {
+      return events.filter((event) => event.name === name);
+    }
+    return events;
+  }
+  async startHandler() {
+    await super.startHandler();
+  }
+  eventsFromPositions(positions) {
+    const events = positions.map((position) => {
+      const events2 = [
+        {
+          name: "StakeAdded",
+          time: position.addBlock,
+          args: {
+            staker: position.staker,
+            staked: position.staked,
+            amount: position.amount,
+            id: position.id
+          }
+        }
+      ];
+      if (position.removeBlock !== 0) {
+        events2.push({
+          name: "StakeRemoved",
+          time: position.removeBlock,
+          args: {
+            staker: position.staker,
+            staked: position.staked,
+            amount: position.amount,
+            id: position.id
+          }
+        });
+      }
+      if (position.withdrawBlock !== 0) {
+        events2.push({
+          name: "StakeWithdrawn",
+          time: position.withdrawBlock,
+          args: {
+            staker: position.staker,
+            staked: position.staked,
+            amount: position.amount,
+            id: position.id
+          }
+        });
+      }
+      return events2;
+    });
+    return events.flat();
+  }
+  positionsFromRange(range) {
+    const startBlock = range[0];
+    const endBlock = range[1] === "latest" ? Number.MAX_SAFE_INTEGER : range[1];
+    const filteredPositions = this.positions?.filter((position) => {
+      return position.addBlock <= endBlock && (position.removeBlock === 0 || position.removeBlock >= startBlock);
+    }) ?? [];
+    return filteredPositions;
+  }
+};
+SimpleStakeEventsViewer = _ts_decorate10([
+  creatableProvider()
+], SimpleStakeEventsViewer);
+
 // src/simple/timesync/SimpleTimeSyncViewer.ts
-import { asHash as asHash6, assertEx as assertEx22, isDefined as isDefined16 } from "@xylabs/sdk-js";
-import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber8, TimeSchema } from "@xyo-network/xl1-protocol";
+import { asHash as asHash6, assertEx as assertEx30, isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { asTimePayload as asTimePayload2, asXL1BlockNumber as asXL1BlockNumber8, TimeSchema } from "@xyo-network/xl1-protocol";
 var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -3698,8 +4784,9 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
     TimeSyncViewerMoniker
   ];
   moniker = _SimpleTimeSyncViewer.defaultMoniker;
+  _blockViewer;
   get blockViewer() {
-    return this.params.blockViewer;
+    return this._blockViewer;
   }
   get ethProvider() {
     return this.params.ethProvider;
@@ -3707,10 +4794,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx22(await this.blockViewer.blockByNumber(asXL1BlockNumber8(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx30(await this.blockViewer.blockByNumber(asXL1BlockNumber8(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const timePayload = asTimePayload(isDefined16(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined18(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -3732,6 +4819,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
       }
     }
   }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
   async currentTime(domain) {
     switch (domain) {
       case "xl1": {
@@ -3773,10 +4864,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
         ];
       }
       case "ethereum": {
-        const provider = assertEx22(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx30(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash6(assertEx22(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash6(assertEx30(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -3787,21 +4878,126 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
       }
     }
   }
-  currentTimePayload() {
-    throw new Error("Method [currentTimePayload] not implemented.");
+  async currentTimePayload() {
+    const [xl1, xl1Hash] = await this.currentTimeAndHash("xl1");
+    const timePayload = {
+      schema: TimeSchema,
+      // this is for the previous block
+      xl1,
+      // this is for the previous block
+      xl1Hash: assertEx30(xl1Hash, () => "No xl1 hash available from time sync service"),
+      epoch: Date.now()
+    };
+    if (isDefined18(this.ethProvider)) {
+      const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
+      const ethereumHash = asHash6(ethHashOrNull, () => "No ethereum hash available from time sync service");
+      timePayload.ethereum = ethereum;
+      timePayload.ethereumHash = ethereumHash;
+    }
+    return timePayload;
+  }
+};
+
+// src/status/ServiceStatus.ts
+var LoggerStatusReporter = class {
+  static {
+    __name(this, "LoggerStatusReporter");
+  }
+  logger;
+  statusMap = {};
+  constructor(logger) {
+    this.logger = logger;
+  }
+  report(name, status, progress) {
+    this.statusMap[name] = status;
+    const starting = Object.entries(this.statusMap).map(([, value]) => value === "starting" ? 1 : 0).reduce((a, b) => a + b, 0);
+    const started = Object.entries(this.statusMap).map(([, value]) => value === "started" ? 1 : 0).reduce((a, b) => a + b, 0);
+    this.logger.info(`${started}/${starting + started} ${name} status: ${status}`, {
+      progress
+    });
+  }
+};
+
+// src/status/RuntimeStatusMonitor.ts
+var statusPriority = {
+  error: 0,
+  stopped: 1,
+  stopping: 2,
+  creating: 3,
+  created: 4,
+  starting: 5,
+  started: 6
+};
+var SENTINEL_STATUS = "starting";
+var reduceToMinimumStatus = /* @__PURE__ */ __name((statuses) => {
+  let minStatus = SENTINEL_STATUS;
+  let minPriority = Infinity;
+  for (const status of statuses) {
+    const priority = statusPriority[status];
+    if (priority < minPriority) {
+      minPriority = priority;
+      minStatus = status;
+    }
+  }
+  return minStatus;
+}, "reduceToMinimumStatus");
+var RuntimeStatusMonitor = class extends LoggerStatusReporter {
+  static {
+    __name(this, "RuntimeStatusMonitor");
+  }
+  globalTransitions = [];
+  transitions = [];
+  getGlobalStatus() {
+    if (Object.keys(this.statusMap).length === 0) return SENTINEL_STATUS;
+    return reduceToMinimumStatus(Object.values(this.statusMap));
+  }
+  getStatus(name) {
+    return this.statusMap[name];
+  }
+  onGlobalTransition(match, handler) {
+    this.globalTransitions.push({
+      ...match,
+      handler
+    });
+  }
+  /**
+  * Register a callback to be called on a specific transition.
+  */
+  onTransition(match, handler) {
+    this.transitions.push({
+      ...match,
+      handler
+    });
+  }
+  report(name, status, progress) {
+    const previous = this.statusMap[name];
+    const previousGlobal = this.getGlobalStatus();
+    super.report(name, status, progress);
+    if (previous === status) return;
+    this.runTransitions(this.transitions, previous, status, name);
+    const globalStatus = this.getGlobalStatus();
+    if (previousGlobal === globalStatus) return;
+    this.runTransitions(this.globalTransitions, previousGlobal, globalStatus);
+  }
+  runTransitions(transitions, prev, next, name) {
+    for (const { from, to, name: matchName, handler } of transitions) {
+      if ((matchName === void 0 || matchName === name) && (from === void 0 || from === prev) && (to === void 0 || to === next)) {
+        handler(prev, next);
+      }
+    }
   }
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx23 } from "@xylabs/sdk-js";
-import { asTimePayload as asTimePayload2, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx31 } from "@xylabs/sdk-js";
+import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context.store, blockHash);
-  const timePayload = asTimePayload2(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
+  const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
     required: true
   });
-  return assertEx23(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx31(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
@@ -3836,13 +5032,20 @@ export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
   AbstractCreatableProvider,
+  AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
+  AccountBalanceQualificationZod,
   AccountBalanceViewerMoniker,
   AddressPairSchema,
   BalancesStepSummarySchema,
   BasisPointsZod,
   BlockRewardViewerMoniker,
+  BlockRunnerMoniker,
+  BlockValidationConfigFieldsZod,
+  BlockValidationConfigZod,
   BlockValidationError,
+  BlockValidationQualificationZod,
+  BlockValidationViewerMoniker,
   BlockViewerMoniker,
   BridgeConfigZod,
   BridgeSettingsZod,
@@ -3850,8 +5053,12 @@ export {
   COIN_TYPES,
   ChainContractViewerMoniker,
   ChainIndexingServiceStateSchema,
+  ChainQualificationZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedHeadConfigZod,
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedZod,
   ChainStakeViewerMoniker,
-  ChainViewerMoniker,
   ConfigZod,
   DEFAULT_WALLET_PATH,
   DataLakeRunnerMoniker,
@@ -3861,14 +5068,17 @@ export {
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
+  ExtendChainQualifiedConfigZod,
   GlobalMetaSchema,
   HydratedBlockStateValidationError,
   HydratedBlockValidationError,
   HydratedCache,
   JSONSchemaMetaSchema,
+  LoggerStatusReporter,
   LruCacheMap,
   MemoryMap,
   MemoryPermissionsStore,
+  MempoolRunnerMoniker,
   MempoolViewerMoniker,
   MnemonicStringZod,
   NetworkStakeStepRewardViewerMoniker,
@@ -3882,17 +5092,19 @@ export {
   PendingTransactionsOptionsZod,
   ProviderFactory,
   ProviderFactoryLocator,
-  QualifiedZod,
   RewardMultipliers,
+  RuntimeStatusMonitor,
   SchemasStepSummarySchema,
   SimpleAccountBalanceViewer,
   SimpleBlockRewardViewer,
+  SimpleBlockValidationViewer,
   SimpleBlockViewer,
-  SimpleChainStakeViewer,
   SimpleDataLakeRunner,
   SimpleDataLakeViewer,
   SimpleMempoolRunner,
   SimpleMempoolViewer,
+  SimpleStakeEventsViewer,
+  SimpleStakeViewer,
   SimpleTimeSyncViewer,
   SimpleXyoClient,
   SimpleXyoGateway,
@@ -3911,6 +5123,10 @@ export {
   StepViewerMoniker,
   TODO,
   TimeSyncViewerMoniker,
+  TransactionBuilder,
+  TransactionValidationConfigZod,
+  TransactionValidationQualificationZod,
+  TransactionValidationViewerMoniker,
   TransferBalanceViewerMoniker,
   TransfersStepSummarySchema,
   TypedDataDomainZod,
@@ -3925,8 +5141,14 @@ export {
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS,
   Xl1CommonConfigSchema,
+  XyoConnectionMoniker,
+  XyoRunnerMoniker,
   XyoViewerMoniker,
+  activeStakeAtTimeByAddress,
+  activeStakeAtTimeByPosition,
   allHashesPresent,
+  allStakersForRange,
+  allStakersForStep,
   asAddressPairPayload,
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
@@ -3944,23 +5166,33 @@ export {
   balancesSummary,
   blockFromBlockNumber,
   blockPayloadsFromHydratedBlock,
+  blockRangeSteps,
+  buildRandomTransaction,
   buildTransaction,
   buildUnsignedTransaction,
   bundledPayloadToHydratedBlock,
   bundledPayloadToHydratedTransaction,
   calculateFramesFromRange,
+  chainStepRewardAddress,
   completedStepRewardAddress,
   confirmSubmittedTransaction,
   contextCache,
   crackOperation,
   crackOperations,
   creatableProvider,
+  createDeclarationIntent,
+  createTransferPayload,
   deepCalculateFramesFromRange,
   derivedReceiveAddress,
   elevatedPayloads,
+  externalBlockNumberFromXL1BlockNumber,
+  externalBlockRangeFromStep,
+  externalBlockRangeFromXL1BlockRange,
   extractElevatedHashes,
   extractElevatedHashesFromScript,
+  findBestUncle,
   findMostRecentBlock,
+  findUncles,
   flattenHydratedBlock,
   flattenHydratedBlocks,
   flattenHydratedTransaction,
@@ -3968,6 +5200,7 @@ export {
   generateXyoBaseWalletFromPhrase,
   getDefaultConfig,
   getUrl,
+  getWindowedChain,
   hasLabels,
   hasMongoConfig,
   hashFromBlockNumber,
@@ -3977,12 +5210,20 @@ export {
   hydratedBlockByNumber,
   hydratedBlockToPayloadBundle,
   hydratedTransactionToPayloadBundle,
+  isAccountBalanceCOnfig,
+  isAccountBalanceQualification,
   isAddressPairPayload,
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,
+  isBlockValidationConfig,
   isBlockValidationError,
+  isBlockValidationQualification,
   isChainIndexingServiceState,
   isChainIndexingServiceStateWithStorageMeta,
+  isChainQualification,
+  isChainQualifiedConfig,
+  isChainQualifiedHeadConfig,
+  isChainQualifiedRangeConfig,
   isEIP712DataPayload,
   isEIP712SignaturePayload,
   isHydratedBlockStateValidationError,
@@ -3994,6 +5235,8 @@ export {
   isReadWriteArchivist,
   isSchemasStepSummary,
   isSchemasStepSummaryWithStorageMeta,
+  isTransactionValidationConfig,
+  isTransactionValidationQualification,
   isTransfersStepSummary,
   isTransfersStepSummaryWithStorageMeta,
   isUsageMeta,
@@ -4001,10 +5244,15 @@ export {
   isZodError,
   labeledCreatableProvider,
   labeledCreatableProviderFactory,
+  mapToMapType,
+  mergeTransfers,
+  mergedAddRemoveStakeEventsByPosition,
   netBalancesForPayloads,
   netSchemasForPayloads,
   netTransfersForPayloads,
+  networkStakeStepRewardPositionWeight,
   parseSignedBigInt,
+  payloadMapFromStore,
   prettifyZodError,
   readPayloadMapFromStore,
   registerCreatableProviderFactories,
@@ -4012,10 +5260,16 @@ export {
   rewardFromBlockNumber,
   schemasStepSummaryFromRange,
   schemasSummary,
+  scoreUncle,
   signEIP712Message,
   signTransaction,
   stepBlockRange,
+  stepRewardBlock,
+  stepRewardTotal,
   stepTransferIndex,
+  stepsRewardTotal,
+  stepsRewardTotalGenesisPeriod,
+  stepsRewardTotalRange,
   timeBudget,
   toPositiveBigInt,
   toSignedBigInt,
@@ -4039,6 +5293,7 @@ export {
   unflattenHydratedBlock,
   unflattenHydratedTransaction,
   verifyEIP712Message,
+  weightedStakeForRangeByPosition,
   withContextCacheResponse,
   xl1BlockNumberToEthBlockNumber
 };