@xyo-network/xl1-protocol-sdk 1.17.6 → 1.18.0-rc.1

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,113 @@ 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/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 +349,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) {
@@ -405,7 +926,7 @@ 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 +937,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();
@@ -471,13 +992,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 assertEx10, 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 +1030,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) ? assertEx10(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -515,30 +1059,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 +1127,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 +1136,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 +1153,9 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } 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 +1207,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 +1221,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 assertEx11(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 +1287,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 assertEx12, 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 +1296,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");
+  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -747,15 +1310,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");
+  assertEx12(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 assertEx13, 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");
+  assertEx13(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [
     account.address
@@ -763,7 +1326,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 +1339,126 @@ async function signTransaction(tx, account) {
 }
 __name(signTransaction, "signTransaction");
 
+// src/transaction/TransactionBuilder.ts
+import { assertEx as assertEx14, 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 = assertEx14(this._chain, () => "Chain must be set before building the transaction");
+    const fees = assertEx14(this._fees, () => "Fees must be set before building the transaction");
+    const blockRange = assertEx14(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 = assertEx14(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,10 +1467,10 @@ var bundle2 = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/model/Provider.ts
-import { assertEx as assertEx10, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx15, isString } from "@xylabs/sdk-js";
 var asProviderMoniker = /* @__PURE__ */ __name((value) => {
   const moniker = isString(value) ? value : void 0;
-  return assertEx10(moniker);
+  return assertEx15(moniker);
 }, "asProviderMoniker");
 var DefaultProviderMoniker = "Provider";
 
@@ -817,7 +1492,7 @@ async function blockFromBlockNumber(context, 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 +1502,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 +1510,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 +1530,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 +1540,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 +1570,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 +1624,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 +1691,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 +1751,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 +1787,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 +1851,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"
@@ -1379,12 +2072,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 +2239,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 assertEx17 } from "@xylabs/sdk-js";
 
 // src/CreatableProvider/ProviderFactory.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
 var ProviderFactory = class _ProviderFactory {
   static {
     __name(this, "ProviderFactory");
@@ -1564,30 +2253,79 @@ 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;
+    assertEx16(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 = assertEx16(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 result = await this.creatableProvider.create(mergedParams);
+    if (start) {
+      assertEx16(await result.start(), () => "Failed to start provider instance");
+    }
+    scopeObject[this.resolvedMoniker] = result;
+    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 +2334,33 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
   static {
     __name(this, "AbstractCreatableProvider");
   }
+  _contextCache;
+  get config() {
+    return assertEx17(this.context.config, () => "config is required");
+  }
+  get context() {
+    return assertEx17(this.params.context, () => "context is required");
+  }
+  get locator() {
+    return assertEx17(this.context.locator, () => "locator is required");
+  }
   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 tryGetInstance(inParams) {
+    try {
+      return await this.create(inParams);
+    } catch {
+      return;
+    }
+  }
+  async locateAndCreate(moniker) {
+    return await this.locator?.getInstance(moniker);
   }
 };
 
@@ -1619,8 +2382,6 @@ __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
     create: provider.create.bind(provider),
@@ -1628,7 +2389,14 @@ var buildProviderFactory = /* @__PURE__ */ __name((provider, 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 +2460,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 assertEx18 } 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 +2484,38 @@ 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);
+    return await factory.getInstance(resolvedParams);
+  }
   /**
-  * 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 assertEx18(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 +2528,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 +2536,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");
+    assertEx18(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
     registerCreatableProviderFactory(this._registry, factory, labels, primary);
     return this;
   }
@@ -1759,19 +2550,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 +2631,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 +2644,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 +2662,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 +2686,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 +2711,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 +2735,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 +2745,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 +2772,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 assertEx22, exists as exists2, isDefined as isDefined16, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber8, 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 +2819,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 assertEx19 } 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 +2842,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);
+    assertEx19(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,21 +2875,21 @@ 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";
+import { asAddress as asAddress3, isDefined as isDefined13, spanRootAsync } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange4 } from "@xyo-network/xl1-protocol";
 async function balancesSummary(context) {
   return await spanRootAsync("balancesSummary", async () => {
     const [headHash] = 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([
+    const rangeStart = asXL1BlockNumber5(isDefined13(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4([
       rangeStart,
       headBoundWitness.block
     ], {
@@ -2150,11 +2916,11 @@ async function balancesSummary(context) {
 __name(balancesSummary, "balancesSummary");
 
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx20 } 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 +2947,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);
+    assertEx20(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,20 +2976,20 @@ 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";
+import { isDefined as isDefined14, spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber6, asXL1BlockRange as asXL1BlockRange5 } from "@xyo-network/xl1-protocol";
 async function schemasSummary(context) {
   return await spanRootAsync2("schemasSummary", async () => {
     const [headHash] = 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([
+    const rangeStart = asXL1BlockNumber6(isDefined14(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange5([
       rangeStart,
       headBoundWitness.block
     ], {
@@ -2249,21 +3015,21 @@ async function schemasSummary(context) {
 __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 assertEx21 } 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";
+import { asAddress as asAddress4, isDefined as isDefined15, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber7, asXL1BlockRange as asXL1BlockRange6 } from "@xyo-network/xl1-protocol";
 async function transfersSummary(transferContext) {
   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([
+    const rangeStart = asXL1BlockNumber7(isDefined15(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0, true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange6([
       rangeStart,
       headBoundWitness.block
     ], {
@@ -2320,8 +3086,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);
+    assertEx21(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,7 +3126,7 @@ async function transfersStepSummaryFromRange(context, range) {
       }
     }
   }
-  const finalResult = await PayloadBuilder13.addStorageMeta(result);
+  const finalResult = await PayloadBuilder16.addStorageMeta(result);
   return finalResult;
 }
 __name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
@@ -2383,9 +3149,6 @@ var BlockViewerMoniker = "BlockViewer";
 // src/viewers/BlockReward.ts
 var BlockRewardViewerMoniker = "BlockRewardViewer";
 
-// src/viewers/Chain.ts
-var ChainViewerMoniker = "ChainViewer";
-
 // src/viewers/ChainContract.ts
 var ChainContractViewerMoniker = "ChainContractViewer";
 
@@ -2455,22 +3218,22 @@ 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 = {}) {
+    assertEx22(params.transfersSummaryContext, () => "transfersSummaryContext is required");
+    assertEx22(params.balanceSummaryContext, () => "balanceSummaryContext is required");
+    return await super.paramsHandler({
+      ...params
+    });
   }
   async accountBalance(address, headOrRange) {
     const balances = await this.accountBalances([
@@ -2483,19 +3246,19 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
   }
   async accountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
-    const startingRange = asXL1BlockRange5(range ?? [
+    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(exists2);
     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(exists2);
       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 assertEx22(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists2).filter((t) => t.from === address || isDefined16(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -2517,11 +3280,15 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     const [result] = await this.qualifiedAccountBalances(address, _headOrRange);
     return result;
   }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
   async qualifiedAccountBalanceHistories(addresses, headOrRange) {
     const head = asHash5(headOrRange) ?? await this.blockViewer.currentBlockHash();
-    const range = asXL1BlockRange5(headOrRange) ?? asXL1BlockRange5([
+    const range = asXL1BlockRange7(headOrRange) ?? asXL1BlockRange7([
       0,
-      assertEx16(await this.blockViewer.blockByHash(head), () => `Error: Could not find block with hash ${head}`)[0].block
+      assertEx22(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,
@@ -2536,8 +3303,8 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     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");
+      assertEx22(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
+      assertEx22(headHash === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
     }
     return [
       Object.fromEntries(entries),
@@ -2547,7 +3314,7 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
   }
   async qualifiedAccountBalances(address, _headOrRange) {
     return await spanRootAsync4("qualifiedAccountsBalances", async () => {
-      const qualifiedSummary = await balancesSummary(this.context);
+      const qualifiedSummary = await balancesSummary(this.balanceSummaryContext);
       const result = {};
       for (const addr of address) {
         const summaryBalance = qualifiedSummary[0][addr] ?? 0n;
@@ -2561,12 +3328,12 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     });
   }
   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));
+      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber8(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 +3346,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 +3371,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] = assertEx22(isDefined16(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(exists2);
     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(exists2);
       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 assertEx22(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists2).filter((t) => t.from === address || isDefined16(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -2645,8 +3412,8 @@ 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 { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber6 } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx23, exists as exists3, isDefined as isDefined17, isUndefined as isUndefined5, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
+import { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber9 } from "@xyo-network/xl1-protocol";
 
 // src/utils/HydratedCache.ts
 import { LRUCache as LRUCache2 } from "lru-cache";
@@ -2704,21 +3471,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 +3493,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");
+    assertEx23(params.finalizedArchivist, () => "finalizedArchivist is required");
     return {
       ...await super.paramsHandler(params)
     };
@@ -2745,13 +3510,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");
+      assertEx23(limit > 0, () => "limit must be greater than 0");
+      assertEx23(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -2765,223 +3544,138 @@ 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");
+      assertEx23(limit > 0, () => "limit must be greater than 0");
+      assertEx23(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByNumber(blockNumber);
       while (current && blocks.length < limit) {
         blocks.push(current);
         if (current[0].block === 0) break;
-        const previousNumber = asXL1BlockNumber6(current[0].block - 1, true);
+        const previousNumber = asXL1BlockNumber9(current[0].block - 1, true);
         current = await this.blockByNumber(previousNumber);
       }
       return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
     }, this.tracer);
   }
+  async chainId(blockNumber = "latest") {
+    return await spanRootAsync5("chainId", async () => {
+      const block = assertEx23(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 = assertEx23(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 assertEx23(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 = assertEx23(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");
-      return asXL1BlockNumber6(currentHead.block, {
-        name: "currentBlockNumber"
-      });
-    }, this.tracer);
-  }
-  async payloadByHash(hash) {
-    const cachedPayload = await this.payloadCache.get(hash);
-    if (cachedPayload) {
-      return cachedPayload;
-    } else {
-      const [result] = await this.finalizedArchivist.get([
-        hash
-      ]);
-      if (isDefined12(result)) {
-        await this.payloadCache.set(hash, result);
-      }
-      return result ?? null;
-    }
-  }
-  async payloadsByHash(hashes) {
-    let remainingHashes = [
-      ...hashes
-    ];
-    const cachedPayloads = await this.payloadCache.getMany(remainingHashes);
-    const cachedHashes = new Set(cachedPayloads.map((p) => p._hash));
-    remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
-    const remainingPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
-    return [
-      ...cachedPayloads,
-      ...remainingPayloads.filter(exists2)
-    ];
-  }
-  async getCurrentHead() {
-    const chainArchivist = this.finalizedArchivist;
-    return await findMostRecentBlock(chainArchivist);
-  }
-};
-SimpleBlockViewer = _ts_decorate2([
-  creatableProvider()
-], SimpleBlockViewer);
-
-// src/simple/blockReward/SimpleBlockRewardViewer.ts
-function _ts_decorate3(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_decorate3, "_ts_decorate");
-var SimpleBlockRewardViewer = class _SimpleBlockRewardViewer extends AbstractCreatableProvider {
-  static {
-    __name(this, "SimpleBlockRewardViewer");
-  }
-  static defaultMoniker = BlockRewardViewerMoniker;
-  static monikers = [
-    BlockRewardViewerMoniker
-  ];
-  moniker = _SimpleBlockRewardViewer.defaultMoniker;
-  rewardFromBlockNumber = rewardFromBlockNumber(18);
-  allowedRewardForBlock(block) {
-    return this.rewardFromBlockNumber(block, this.params.initialReward, this.params.stepSize, this.params.stepFactorNumerator, this.params.stepFactorDenominator, this.params.minRewardPerBlock, this.params.creatorReward);
-  }
-};
-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";
-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);
-  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_decorate4, "_ts_decorate");
-var SimpleChainStakeEventsViewer = class _SimpleChainStakeEventsViewer extends AbstractCreatableProvider {
-  static {
-    __name(this, "SimpleChainStakeEventsViewer");
-  }
-  static defaultMoniker = StakeEventsViewerMoniker;
-  static monikers = [
-    StakeEventsViewerMoniker
-  ];
-  moniker = _SimpleChainStakeEventsViewer.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 (isDefined13(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 await spanRootAsync5("currentBlockNumber", async () => {
+      const currentHead = assertEx23(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockNumber]");
+      return asXL1BlockNumber9(currentHead.block, {
+        name: "currentBlockNumber"
+      });
+    }, this.tracer);
+  }
+  async payloadByHash(hash) {
+    const cachedPayload = await this.payloadCache.get(hash);
+    if (cachedPayload) {
+      return cachedPayload;
+    } else {
+      const [result] = await this.finalizedArchivist.get([
+        hash
+      ]);
+      if (isDefined17(result)) {
+        await this.payloadCache.set(hash, result);
       }
-      return events2;
-    });
-    return events.flat();
+      return result ?? null;
+    }
   }
-  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 payloadsByHash(hashes) {
+    let remainingHashes = [
+      ...hashes
+    ];
+    const cachedPayloads = await this.payloadCache.getMany(remainingHashes);
+    const cachedHashes = new Set(cachedPayloads.map((p) => p._hash));
+    remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
+    const remainingPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
+    return [
+      ...cachedPayloads,
+      ...remainingPayloads.filter(exists3)
+    ];
+  }
+  async getCurrentHead() {
+    const chainArchivist = this.finalizedArchivist;
+    return await findMostRecentBlock(chainArchivist);
   }
 };
-SimpleChainStakeEventsViewer = _ts_decorate4([
+SimpleBlockViewer = _ts_decorate2([
   creatableProvider()
-], SimpleChainStakeEventsViewer);
+], SimpleBlockViewer);
 
-// src/simple/chainStake/SimpleChainStakeViewer.ts
-function _ts_decorate5(decorators, target, key, desc) {
+// src/simple/blockReward/SimpleBlockRewardViewer.ts
+function _ts_decorate3(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_decorate5, "_ts_decorate");
-var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreatableProvider {
+__name(_ts_decorate3, "_ts_decorate");
+var SimpleBlockRewardViewer = class _SimpleBlockRewardViewer extends AbstractCreatableProvider {
+  static {
+    __name(this, "SimpleBlockRewardViewer");
+  }
+  static defaultMoniker = BlockRewardViewerMoniker;
+  static monikers = [
+    BlockRewardViewerMoniker
+  ];
+  moniker = _SimpleBlockRewardViewer.defaultMoniker;
+  rewardFromBlockNumber = rewardFromBlockNumber(18);
+  allowedRewardForBlock(block) {
+    return this.rewardFromBlockNumber(block, this.params.initialReward, this.params.stepSize, this.params.stepFactorNumerator, this.params.stepFactorDenominator, this.params.minRewardPerBlock, this.params.creatorReward);
+  }
+};
+SimpleBlockRewardViewer = _ts_decorate3([
+  creatableProvider()
+], SimpleBlockRewardViewer);
+
+// src/simple/chainStake/SimpleStakeViewer.ts
+import { asAddress as asAddress5, toAddress as toAddress9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx24 } from "@xylabs/sdk-js";
+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);
+  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_decorate4, "_ts_decorate");
+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 +3683,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 assertEx24(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
-    return toAddress6("0x000000000000000000000000000011");
+    return toAddress9("0x000000000000000000000000000011");
   }
   get positions() {
     return this.params.positions;
@@ -3027,6 +3721,10 @@ var SimpleChainStakeViewer = class _SimpleChainStakeViewer extends AbstractCreat
     }
     return active;
   }
+  async createHandler() {
+    await super.createHandler();
+    this._chainStakeEventsViewer = assertEx24(await this.locateAndCreate(StakeEventsViewerMoniker), () => "Failed to create StakeEventsViewer");
+  }
   pending() {
     let pending = 0n;
     for (const position of this.positions) {
@@ -3046,7 +3744,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 assertEx24(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 +3781,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_decorate4([
   creatableProvider()
-], SimpleChainStakeViewer);
+], SimpleStakeViewer);
 
 // src/simple/client/SimpleXyoClient.ts
 var SimpleXyoClient = class {
@@ -3123,21 +3814,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);
@@ -3156,13 +3847,13 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
 };
 
 // src/simple/datalake/SimpleDataLakeRunner.ts
-function _ts_decorate6(decorators, target, key, desc) {
+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);
   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_decorate6, "_ts_decorate");
+__name(_ts_decorate5, "_ts_decorate");
 var SimpleDataLakeRunner = class _SimpleDataLakeRunner extends AbstractSimpleDataLake {
   static {
     __name(this, "SimpleDataLakeRunner");
@@ -3188,19 +3879,18 @@ var SimpleDataLakeRunner = class _SimpleDataLakeRunner extends AbstractSimpleDat
     return await this.map.setMany(allowed);
   }
 };
-SimpleDataLakeRunner = _ts_decorate6([
+SimpleDataLakeRunner = _ts_decorate5([
   creatableProvider()
 ], SimpleDataLakeRunner);
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
-import { isAnyPayload as isAnyPayload5 } from "@xyo-network/payload-model";
-function _ts_decorate7(decorators, target, key, desc) {
+function _ts_decorate6(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_decorate7, "_ts_decorate");
+__name(_ts_decorate6, "_ts_decorate");
 var SimpleDataLakeViewer = class _SimpleDataLakeViewer extends AbstractSimpleDataLake {
   static {
     __name(this, "SimpleDataLakeViewer");
@@ -3210,23 +3900,8 @@ 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([
+SimpleDataLakeViewer = _ts_decorate6([
   creatableProvider()
 ], SimpleDataLakeViewer);
 
@@ -3256,9 +3931,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 assertEx25, BigIntToJsonZod, isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/payload-builder";
+import { asXL1BlockNumber as asXL1BlockNumber10, TransferSchema as TransferSchema3 } from "@xyo-network/xl1-protocol";
 var SimpleXyoGatewayRunner = class {
   static {
     __name(this, "SimpleXyoGatewayRunner");
@@ -3287,18 +3962,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 = assertEx25(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 = isDefined18(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber10(isDefined18(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber10(isDefined18(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 = assertEx25(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
@@ -3310,7 +3985,7 @@ var SimpleXyoGatewayRunner = class {
     ];
   }
   async confirmSubmittedTransaction(txHash, options) {
-    return await confirmSubmittedTransaction(assertEx19(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
+    return await confirmSubmittedTransaction(assertEx25(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
   }
   /** @deprecated use connectionInstance instead */
   connection() {
@@ -3330,8 +4005,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,19 +4031,23 @@ 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";
-function _ts_decorate8(decorators, target, key, desc) {
+import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/payload-builder";
+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);
   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_decorate8, "_ts_decorate");
-var SimpleMempoolRunner = class extends AbstractCreatable2 {
+__name(_ts_decorate7, "_ts_decorate");
+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 +4057,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,28 +4067,28 @@ 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()
+SimpleMempoolRunner = _ts_decorate7([
+  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 exists4, isDefined as isDefined19, isHash } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle } from "@xyo-network/payload-model";
-function _ts_decorate9(decorators, target, key, desc) {
+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);
   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_decorate9, "_ts_decorate");
+__name(_ts_decorate8, "_ts_decorate");
 var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleMempoolViewer");
@@ -3431,7 +4110,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingBlocksArchivist.get([
         providedCursor
       ]);
-      if (isDefined15(p)) {
+      if (isDefined19(p)) {
         cursor = p._sequence;
       }
     }
@@ -3441,7 +4120,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(exists4);
   }
   async pendingTransactions({ cursor: providedCursor } = {}) {
     let cursor = void 0;
@@ -3449,25 +4128,30 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingTransactionsArchivist.get([
         providedCursor
       ]);
-      if (isDefined15(p)) {
+      if (isDefined19(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(exists4);
+    this.logger?.info(`Converted pending transactions: ${JSON.stringify(result, null, 2)} results`);
+    return result;
   }
 };
-SimpleMempoolViewer = _ts_decorate9([
-  creatable2()
+SimpleMempoolViewer = _ts_decorate8([
+  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 +4198,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 +4223,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { assertEx as assertEx26 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -3551,7 +4235,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx20(this._store, () => "Store must be defined to get permissions");
+    return assertEx26(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -3609,7 +4293,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx21 } from "@xylabs/sdk-js";
+import { assertEx as assertEx27 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -3620,7 +4304,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx21(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx27(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -3633,33 +4317,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 assertEx28 } 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: assertEx28(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 +4379,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 isDefined20 } from "@xylabs/sdk-js";
+function _ts_decorate9(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_decorate9, "_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 (isDefined20(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_decorate9([
+  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 assertEx29, isDefined as isDefined21 } from "@xylabs/sdk-js";
+import { asTimePayload as asTimePayload2, asXL1BlockNumber as asXL1BlockNumber11, TimeSchema } from "@xyo-network/xl1-protocol";
 var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -3698,8 +4487,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 +4497,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] = assertEx29(await this.blockViewer.blockByNumber(asXL1BlockNumber11(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(isDefined21(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -3732,6 +4522,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 +4567,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
         ];
       }
       case "ethereum": {
-        const provider = assertEx22(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx29(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(assertEx29(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -3787,21 +4581,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: assertEx29(xl1Hash, () => "No xl1 hash available from time sync service"),
+      epoch: Date.now()
+    };
+    if (isDefined21(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 assertEx30 } 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 assertEx30(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
@@ -3842,6 +4741,7 @@ export {
   BalancesStepSummarySchema,
   BasisPointsZod,
   BlockRewardViewerMoniker,
+  BlockRunnerMoniker,
   BlockValidationError,
   BlockViewerMoniker,
   BridgeConfigZod,
@@ -3851,7 +4751,6 @@ export {
   ChainContractViewerMoniker,
   ChainIndexingServiceStateSchema,
   ChainStakeViewerMoniker,
-  ChainViewerMoniker,
   ConfigZod,
   DEFAULT_WALLET_PATH,
   DataLakeRunnerMoniker,
@@ -3866,9 +4765,11 @@ export {
   HydratedBlockValidationError,
   HydratedCache,
   JSONSchemaMetaSchema,
+  LoggerStatusReporter,
   LruCacheMap,
   MemoryMap,
   MemoryPermissionsStore,
+  MempoolRunnerMoniker,
   MempoolViewerMoniker,
   MnemonicStringZod,
   NetworkStakeStepRewardViewerMoniker,
@@ -3884,15 +4785,17 @@ export {
   ProviderFactoryLocator,
   QualifiedZod,
   RewardMultipliers,
+  RuntimeStatusMonitor,
   SchemasStepSummarySchema,
   SimpleAccountBalanceViewer,
   SimpleBlockRewardViewer,
   SimpleBlockViewer,
-  SimpleChainStakeViewer,
   SimpleDataLakeRunner,
   SimpleDataLakeViewer,
   SimpleMempoolRunner,
   SimpleMempoolViewer,
+  SimpleStakeEventsViewer,
+  SimpleStakeViewer,
   SimpleTimeSyncViewer,
   SimpleXyoClient,
   SimpleXyoGateway,
@@ -3911,6 +4814,7 @@ export {
   StepViewerMoniker,
   TODO,
   TimeSyncViewerMoniker,
+  TransactionBuilder,
   TransferBalanceViewerMoniker,
   TransfersStepSummarySchema,
   TypedDataDomainZod,
@@ -3925,8 +4829,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,20 +4854,28 @@ 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,
   findMostRecentBlock,
@@ -4001,10 +4919,15 @@ export {
   isZodError,
   labeledCreatableProvider,
   labeledCreatableProviderFactory,
+  mapToMapType,
+  mergeTransfers,
+  mergedAddRemoveStakeEventsByPosition,
   netBalancesForPayloads,
   netSchemasForPayloads,
   netTransfersForPayloads,
+  networkStakeStepRewardPositionWeight,
   parseSignedBigInt,
+  payloadMapFromStore,
   prettifyZodError,
   readPayloadMapFromStore,
   registerCreatableProviderFactories,
@@ -4015,7 +4938,12 @@ export {
   signEIP712Message,
   signTransaction,
   stepBlockRange,
+  stepRewardBlock,
+  stepRewardTotal,
   stepTransferIndex,
+  stepsRewardTotal,
+  stepsRewardTotalGenesisPeriod,
+  stepsRewardTotalRange,
   timeBudget,
   toPositiveBigInt,
   toSignedBigInt,
@@ -4039,6 +4967,7 @@ export {
   unflattenHydratedBlock,
   unflattenHydratedTransaction,
   verifyEIP712Message,
+  weightedStakeForRangeByPosition,
   withContextCacheResponse,
   xl1BlockNumberToEthBlockNumber
 };