@xyo-network/xl1-protocol-sdk 1.16.26 → 1.17.1

package/dist/neutral/index.mjs

@@ -108,12 +108,12 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 }, "tryHydrateBlock");
 
 // src/block/primitives/blockFromBlockNumber.ts
-import { asHash as asHash3, isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { asHash as asHash3, isDefined as isDefined6 } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
-import { asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
+import { asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol";
 
 // src/model/ChainContext/ChainContext.ts
-import { isDefined as isDefined7, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined4, isUndefined } from "@xylabs/sdk-js";
 
 // src/driver/cache/LruCacheMap.ts
 import { LRUCache } from "lru-cache";
@@ -225,6 +225,66 @@ function readPayloadMapFromStore(store) {
 }
 __name(readPayloadMapFromStore, "readPayloadMapFromStore");
 
+// 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(30000n, places)), blocksPerStep = 1e6, stepFactorNumerator = 90n, stepFactorDenominator = 100n, minBlockReward = asAttoXL1(toFixedPoint(30n, places)), creatorReward = asAttoXL1(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 asAttoXL1(reward < minBlockReward ? minBlockReward : reward);
+  };
+}, "rewardFromBlockNumber");
+
+// src/primitives/state/findMostRecentBlock.ts
+import { isSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var DEFAULT_NEXT_OPTIONS = {
+  limit: 50
+};
+var findMostRecentBlock = /* @__PURE__ */ __name(async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTIONS, maxIterations = Number.POSITIVE_INFINITY) => {
+  let mostRecentBlock;
+  let cursor;
+  let batch;
+  let iterations = 0;
+  do {
+    batch = await chainArchivist.next({
+      ...nextOptions,
+      order: "desc",
+      cursor
+    });
+    const blocks = batch.filter(isSignedBlockBoundWitnessWithStorageMeta);
+    const last = blocks?.at(0);
+    if (last) {
+      mostRecentBlock = last;
+      break;
+    } else {
+      cursor = batch.at(-1)?._sequence;
+    }
+    iterations = iterations + 1;
+  } while (batch.length > 0 && iterations < maxIterations);
+  return mostRecentBlock;
+}, "findMostRecentBlock");
+
+// src/primitives/state/hydratedBlockByNumber.ts
+import { assertEx as assertEx4 } 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}`);
+    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";
@@ -265,7 +325,7 @@ function stepBlockRange({ block, step }) {
 __name(stepBlockRange, "stepBlockRange");
 
 // src/primitives/step/stepTransferIndex.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
 function stepTransferIndex(block, step) {
   let rewardTransferCount = 0;
@@ -279,7 +339,7 @@ function stepTransferIndex(block, step) {
       rewardTransferCount++;
     }
   }
-  assertEx4(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
+  assertEx5(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
   return [
     rewardTransferIndex,
     rewardTransferCount
@@ -287,1026 +347,621 @@ function stepTransferIndex(block, step) {
 }
 __name(stepTransferIndex, "stepTransferIndex");
 
-// src/primitives/summary/balances/balancesStepSummaryFromRange.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { isAnyPayload } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes4 } 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, toAddress as toAddress3 } from "@xylabs/sdk-js";
-import { span } from "@xylabs/telemetry";
-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[toAddress3(address)] = (balances[toAddress3(address)] ?? 0n) + hexToBigInt(amount);
-          balances[toAddress3(from)] = (balances[toAddress3(from)] ?? 0n) - hexToBigInt(amount);
-        }
-      }
+// src/primitives/timeBudget.ts
+async function timeBudget(name, logger, func, budget, status = false) {
+  const start = Date.now();
+  const timer = status ? setInterval(() => {
+    const duration2 = Date.now() - start;
+    if (budget > 0 && duration2 > budget) {
+      logger?.warn(`Function [${name}] execution is exceeding budget: ${duration2}ms > ${budget}ms`);
     }
-    return balances;
-  });
-}, "netBalancesForPayloads");
+  }, Math.max(100, budget)) : void 0;
+  const result = await func();
+  const duration = Date.now() - start;
+  if (!timer && budget > 0 && duration > budget) {
+    logger?.warn(`Function [${name}] execution exceeded budget: ${duration}ms > ${budget}ms`);
+  }
+  if (timer) {
+    clearInterval(timer);
+  }
+  return result;
+}
+__name(timeBudget, "timeBudget");
 
-// src/payloads/netSchemasForPayloads.ts
-import { hexToBigInt as hexToBigInt2, toAddress as toAddress4 } from "@xylabs/sdk-js";
-import { span as span2 } from "@xylabs/telemetry";
-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[toAddress4(address)] = (balances[toAddress4(address)] ?? 0n) + hexToBigInt2(amount);
-          balances[toAddress4(from)] = (balances[toAddress4(from)] ?? 0n) - hexToBigInt2(amount);
-        }
+// src/primitives/transaction/elevatedPayloads.ts
+import { isAllowedBlockPayload } from "@xyo-network/xl1-protocol";
+var ELEVATE_OPCODE = "elevate";
+function elevatedPayloads([tx, payloads]) {
+  const opCodes = (tx.script ?? []).filter((operation) => operation.startsWith(`${ELEVATE_OPCODE}|`));
+  const elevatedPayloads2 = [];
+  for (const opCode of opCodes) {
+    const [code, hash] = opCode.split("|");
+    if (code === ELEVATE_OPCODE) {
+      const elevatedPayload = payloads.find((payload) => payload._hash === hash);
+      if (isAllowedBlockPayload(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
       }
     }
-    return balances;
-  });
-}, "netSchemasForPayloads");
+  }
+  if (opCodes.length === elevatedPayloads2.length) {
+    return elevatedPayloads2;
+  }
+  throw new Error("Not all elevated payloads could be found in the transaction payloads");
+}
+__name(elevatedPayloads, "elevatedPayloads");
 
-// src/payloads/netTransfersForPayloads.ts
-import { hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
-import { span as span3 } from "@xylabs/telemetry";
-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;
-  });
+// src/model/ChainContext/ChainContext.ts
+function contextCache(context, name, create) {
+  if (!context.caches) {
+    context.caches = {};
+  }
+  if (isUndefined(context.caches[name])) {
+    context.caches[name] = create?.() ?? new MemoryMap();
+  }
+  return context.caches[name];
 }
-__name(netTransfersForPayloads, "netTransfersForPayloads");
+__name(contextCache, "contextCache");
+async function withContextCacheResponse(context, name, key, func, { max = 1e4, timeBudgetMs = 0 } = {}) {
+  const cache = contextCache(context, name, () => new LruCacheMap({
+    max
+  }));
+  const cacheResult = await cache.get(key);
+  if (isDefined4(cacheResult)) {
+    return cacheResult;
+  }
+  const result = timeBudgetMs > 0 ? await timeBudget(name, context.logger, func, timeBudgetMs) : await func();
+  await cache.set(key, result);
+  return result;
+}
+__name(withContextCacheResponse, "withContextCacheResponse");
 
-// src/payloads/summary/BalancesStepSummary.ts
-import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isStorageMeta } from "@xyo-network/payload-model";
-var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
-var isBalancesStepSummary = isPayloadOfSchemaType2(BalancesStepSummarySchema);
-var asBalancesStepSummary = AsObjectFactory2.create(isBalancesStepSummary);
-var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
-  return isBalancesStepSummary(value) && isStorageMeta(value);
-}, "isBalancesStepSummaryWithStorageMeta");
-var asBalancesStepSummaryWithStorageMeta = AsObjectFactory2.create(isBalancesStepSummaryWithStorageMeta);
+// src/model/PayloadBundle/bundledPayloadToHydratedBlock.ts
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { asSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+var bundledPayloadToHydratedBlock = /* @__PURE__ */ __name(async (payload) => {
+  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads);
+  const tx = asSignedBlockBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
+  if (tx) {
+    return [
+      tx,
+      withHashMeta.filter((p) => p._hash !== payload.root)
+    ];
+  }
+}, "bundledPayloadToHydratedBlock");
 
-// src/payloads/summary/SchemasStepSummary.ts
-import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType3, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
-var SchemasStepSummarySchema = "network.xyo.step.summary.schemas";
-var isSchemasStepSummary = isPayloadOfSchemaType3(SchemasStepSummarySchema);
-var asSchemasStepSummary = AsObjectFactory3.create(isSchemasStepSummary);
-var isSchemasStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
-  return isSchemasStepSummary(value) && isStorageMeta2(value);
-}, "isSchemasStepSummaryWithStorageMeta");
-var asSchemasStepSummaryWithStorageMeta = AsObjectFactory3.create(isSchemasStepSummaryWithStorageMeta);
+// src/model/PayloadBundle/bundledPayloadToHydratedTransaction.ts
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
+  const withHashMeta = await PayloadBuilder2.addHashMeta(payload.payloads);
+  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
+  if (tx) {
+    return [
+      tx,
+      withHashMeta.filter((p) => p._hash !== payload.root)
+    ];
+  }
+}, "bundledPayloadToHydratedTransaction");
 
-// src/payloads/summary/StepSummary.ts
-var StepSummarySchema = "network.xyo.step.summary";
+// src/model/PayloadBundle/hydratedBlockToPayloadBundle.ts
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBundleSchema } from "@xyo-network/payload-model";
+var hydratedBlockToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
+  const root = transaction[0]._hash;
+  return bundle(root, transaction);
+}, "hydratedBlockToPayloadBundle");
+var bundle = /* @__PURE__ */ __name((root, transaction) => {
+  const payloads = flattenHydratedBlock(transaction).flatMap((p) => PayloadBuilder3.omitStorageMeta(p));
+  return new PayloadBuilder3({
+    schema: PayloadBundleSchema
+  }).fields({
+    payloads,
+    root
+  }).build();
+}, "bundle");
 
-// src/payloads/summary/TransfersSummary.ts
-import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType4, isStorageMeta as isStorageMeta3 } from "@xyo-network/payload-model";
-var TransfersStepSummarySchema = "network.xyo.step.summary.transfer";
-var isTransfersStepSummary = isPayloadOfSchemaType4(TransfersStepSummarySchema);
-var asTransfersStepSummary = AsObjectFactory4.create(isTransfersStepSummary);
-var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
-  return isTransfersStepSummary(value) && isStorageMeta3(value);
-}, "isTransfersStepSummaryWithStorageMeta");
-var asTransfersStepSummaryWithStorageMeta = AsObjectFactory4.create(isTransfersStepSummaryWithStorageMeta);
+// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBundleSchema as PayloadBundleSchema2 } from "@xyo-network/payload-model";
 
-// src/SignedBigInt.ts
-import { hexToBigInt as hexToBigInt4, toHex } 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";
-}, "isNegativeBigInt");
-var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
-  return isObject(value) && "positive" in value && typeof value.positive === "string";
-}, "isPositiveBigInt");
-var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
-  if (isNegativeBigInt(value)) {
-    return -hexToBigInt4(value.negative);
-  } else if (isPositiveBigInt(value)) {
-    return hexToBigInt4(value.positive);
-  } else {
-    throw new Error("Invalid balance type");
+// src/transaction/buildTransaction.ts
+import { assertEx as assertEx6, toHex } from "@xylabs/sdk-js";
+import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
+import { PayloadBuilder as PayloadBuilder4 } 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)) {
+    throw new Error("from is required when signer is an array");
   }
-}, "parseSignedBigInt");
-var toSignedBigInt = /* @__PURE__ */ __name((value) => {
-  return value < 0n ? {
-    negative: toHex(-value)
-  } : {
-    positive: toHex(value)
+  const txBoundWitnessFields = {
+    chain,
+    fees: {
+      base: toHex(fees.base),
+      gasLimit: toHex(fees.gasLimit),
+      gasPrice: toHex(fees.gasPrice),
+      priority: toHex(fees.priority)
+    },
+    nbf,
+    exp
   };
-}, "toSignedBigInt");
-var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
-  if (isNegativeBigInt(value)) {
-    return {
-      positive: toHex(0n)
-    };
-  }
-  if (isPositiveBigInt(value)) {
-    return {
-      positive: value.positive
-    };
+  const elevatedHashes = await PayloadBuilder4.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
   }
-  if (typeof value === "bigint") {
-    return {
-      positive: toHex(value)
-    };
+  const fields = {
+    ...txBoundWitnessFields,
+    from: from ?? (Array.isArray(signer) ? assertEx6(signer.at(0)?.address) : signer.address)
+  };
+  if (script.length > 0) {
+    fields.script = script;
   }
-  throw new Error("Invalid value for positive big int");
-}, "toPositiveBigInt");
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).signers(Array.isArray(signer) ? signer : [
+    signer
+  ]).build();
+  return [
+    await PayloadBuilder4.addHashMeta(tx),
+    await PayloadBuilder4.addHashMeta(txPayloads)
+  ];
+}
+__name(buildTransaction, "buildTransaction");
 
-// src/primitives/summary/balances/balancesStepSummaryFromRange.ts
-async function balancesStepSummaryFromRange(context, range) {
-  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
-  const frameSize = range[1] - range[0] + 1;
-  const [headHash] = await context.head();
-  let result = void 0;
-  if (frameSize === 1) {
-    const hash = await hashFromBlockNumber(context, range[0]);
-    const [, payloads] = await hydrateBlock(context.store, hash);
-    const balances = {};
-    for (const [address, balance] of Object.entries(netBalancesForPayloads(payloads))) {
-      balances[address] = toSignedBigInt(balance);
-    }
-    result = {
-      schema: BalancesStepSummarySchema,
-      hash: headHash,
-      stepSize: -1,
-      balances
-    };
-  } else {
-    const step = StepSizes4.indexOf(frameSize);
-    assertEx5(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
-    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
-    if (isAnyPayload(summaryResult)) {
-      result = summaryResult;
-    } else {
-      await context.stepSemaphores[step].acquire();
-      try {
-        const subRanges = deepCalculateFramesFromRange(range, step - 1);
-        const promises = subRanges.map((subRange) => balancesStepSummaryFromRange(context, subRange));
-        const subResults = await Promise.all(promises);
-        const bigIntBalances = {};
-        for (const subResult of subResults) {
-          for (const [address, balance] of Object.entries(subResult.balances)) {
-            bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(balance);
-          }
-        }
-        const balances = {};
-        for (const [address, balance] of Object.entries(bigIntBalances)) {
-          balances[address] = toSignedBigInt(balance);
-        }
-        result = {
-          schema: BalancesStepSummarySchema,
-          hash: frameHeadHash,
-          stepSize: frameSize,
-          balances
-        };
-        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
-      } finally {
-        context.stepSemaphores[step].release();
-      }
-    }
+// src/transaction/buildUnsignedTransaction.ts
+import { toHex as toHex2 } from "@xylabs/sdk-js";
+import { BoundWitnessBuilder as BoundWitnessBuilder2 } from "@xyo-network/boundwitness-builder";
+import { PayloadBuilder as PayloadBuilder5 } 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)
+    },
+    nbf,
+    exp
+  };
+  const elevatedHashes = await PayloadBuilder5.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
   }
-  const finalResult = await PayloadBuilder.addStorageMeta(result);
-  return finalResult;
+  const fields = {
+    ...txBoundWitnessFields,
+    from
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).build(false);
+  return [
+    tx,
+    txPayloads
+  ];
 }
-__name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
+__name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
-// src/primitives/summary/balances/balancesSummary.ts
-import { asAddress, isDefined as isDefined4 } from "@xylabs/sdk-js";
-import { spanRootAsync } from "@xylabs/telemetry";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockNumber, asXL1BlockRange as asXL1BlockRange2 } 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 = asXL1BlockNumber(isDefined4(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange2([
-      rangeStart,
-      headBoundWitness.block
-    ], {
-      name: "balancesSummary"
-    }));
-    const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
-    const balances = {};
-    for (let summary of summaries) {
-      for (const [address, balance] of Object.entries(summary.balances)) {
-        const validAddress = asAddress(address, () => `Invalid address: ${address}`);
-        balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance);
+// src/transaction/confirmSubmittedTransaction.ts
+import { delay, isDefined as isDefined5 } from "@xylabs/sdk-js";
+var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
+var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
+var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash, options) => {
+  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {};
+  options?.logger?.log("\u{1F680} confirming transaction:", txHash, "\n");
+  let attempts = 0;
+  while (true) {
+    const tx = await viewer.transactionByHash(txHash) ?? void 0;
+    if (isDefined5(tx)) {
+      options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
+      return tx;
+    } else {
+      attempts++;
+      if (attempts > maxAttempts) {
+        options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
+        throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
+      } else {
+        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
+        await delay(attemptDelay);
       }
     }
-    return balances;
-  });
-}
-__name(balancesSummary, "balancesSummary");
+  }
+}, "confirmSubmittedTransaction");
 
-// src/primitives/summary/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { isBoundWitness } from "@xyo-network/boundwitness-model";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { isAnyPayload as isAnyPayload2, isHashMeta } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
-async function schemasStepSummaryFromRange(context, range) {
-  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
-  const frameSize = range[1] - range[0] + 1;
-  const [headHash] = await context.head();
-  let result = void 0;
-  if (frameSize === 1) {
-    const hash = await hashFromBlockNumber(context, range[0]);
-    const [block, payloads] = await hydrateBlock(context.store, hash);
-    const boundWitnesses = [
-      block,
-      ...payloads.filter((x) => isBoundWitness(x) && isHashMeta(x))
-    ];
-    const schemas = {};
-    for (const bw of boundWitnesses) {
-      schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1;
-      for (const schema of bw.payload_schemas) {
-        schemas[schema] = (schemas[schema] ?? 0) + 1;
-      }
+// src/transaction/hydrateTransaction.ts
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
+import { isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
+  return await tryHydrateTypedBoundWitness({
+    get(hashes) {
+      return chainMap.getMany(hashes);
+    },
+    next() {
+      throw new Error("Not implemented");
     }
-    result = {
-      schema: SchemasStepSummarySchema,
-      hash: headHash,
-      stepSize: -1,
-      schemas
-    };
-  } else {
-    const step = StepSizes5.indexOf(frameSize);
-    assertEx6(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes5.join(", ")}`);
-    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
-    if (isAnyPayload2(summaryResult)) {
-      result = summaryResult;
-    } else {
-      await context.stepSemaphores[step].acquire();
-      try {
-        const subRanges = deepCalculateFramesFromRange(range, step - 1);
-        const promises = subRanges.map((subRange) => schemasStepSummaryFromRange(context, subRange));
-        const subResults = await Promise.all(promises);
-        const schemas = {};
-        for (const subResult of subResults) {
-          for (const [schema, count] of Object.entries(subResult.schemas)) {
-            schemas[schema] = (schemas[schema] ?? 0) + count;
-          }
-        }
-        result = {
-          schema: SchemasStepSummarySchema,
-          hash: frameHeadHash,
-          stepSize: frameSize,
-          schemas
-        };
-        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
-      } finally {
-        context.stepSemaphores[step].release();
+  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "tryHydrateTransaction");
+var hydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
+  return await hydrateTypedBoundWitness({
+    get(hashes) {
+      return chainMap.getMany(hashes);
+    },
+    next() {
+      throw new Error("Not implemented");
+    }
+  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "hydrateTransaction");
+var flattenHydratedTransaction = /* @__PURE__ */ __name((hydratedTransaction) => {
+  const [tx, txPayloads] = hydratedTransaction;
+  return [
+    ...txPayloads,
+    tx
+  ];
+}, "flattenHydratedTransaction");
+var flattenHydratedTransactions = /* @__PURE__ */ __name((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
+var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
+  const hydratedTransaction = await tryHydrateTransaction({
+    chainMap
+  }, hash);
+  if (!hydratedTransaction) {
+    return void 0;
+  }
+  const [transaction, payloads] = hydratedTransaction;
+  const opCodes = (transaction.script ?? []).filter((operation) => operation.startsWith("elevate|"));
+  const elevatedPayloads2 = [];
+  for (const opCode of opCodes) {
+    const [code, hash2] = opCode.split("|");
+    if (code === "elevated") {
+      const elevatedPayload = payloads.find((payload) => payload._hash === hash2);
+      if (isAllowedBlockPayload2(elevatedPayload)) {
+        elevatedPayloads2.push(elevatedPayload);
       }
     }
   }
-  return await PayloadBuilder2.addHashMeta(result);
+  if (opCodes.length === elevatedPayloads2.length) {
+    return [
+      transaction,
+      elevatedPayloads2
+    ];
+  }
+  return void 0;
+}, "tryHydrateElevatedTransaction");
+var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
+  return assertEx7(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+}, "hydrateElevatedTransaction");
+
+// src/transaction/primitives/transactionBlockByteCount.ts
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+function transactionBlockByteCount([transaction, payloads]) {
+  const cleanTransaction = PayloadBuilder6.omitStorageMeta(transaction);
+  const transactionBytes = JSON.stringify(cleanTransaction).length;
+  const cleanPayloads = PayloadBuilder6.omitStorageMeta(payloads);
+  return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
-__name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
+__name(transactionBlockByteCount, "transactionBlockByteCount");
 
-// src/primitives/summary/schemas/schemasSummary.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber2, asXL1BlockRange as asXL1BlockRange3 } 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 = asXL1BlockNumber2(isDefined5(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange3([
-      rangeStart,
-      headBoundWitness.block
-    ], {
-      name: "schemasSummary"
-    }));
-    const summaries = await Promise.all(ranges.map((range) => schemasStepSummaryFromRange(context, range)));
-    const schemas = {};
-    for (let summary of summaries) {
-      for (const [schema, count] of Object.entries(summary.schemas)) {
-        schemas[schema] = (schemas[schema] ?? 0) + count;
-      }
-    }
-    return schemas;
-  });
+// src/transaction/primitives/transactionElevatedPayloads.ts
+import { asHash } from "@xylabs/sdk-js";
+
+// src/transaction/primitives/transactionOperations.ts
+function crackOperation(operation) {
+  const parts = operation.split("|");
+  if (parts.length < 2) {
+    throw new Error(`Invalid operation format: ${operation}`);
+  }
+  return [
+    parts[0],
+    parts.slice(1)
+  ];
 }
-__name(schemasSummary, "schemasSummary");
+__name(crackOperation, "crackOperation");
+function crackOperations(operations) {
+  return operations.map((op) => crackOperation(op));
+}
+__name(crackOperations, "crackOperations");
 
-// src/primitives/summary/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
+// src/transaction/primitives/transactionElevatedPayloads.ts
+function transactionElevatedPayloadHashes(transaction) {
+  const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
+  return elevateOperations.map((op) => asHash(op[1][0], true));
+}
+__name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
+function transactionElevatedPayloads([transaction, payloads]) {
+  const hashes = transactionElevatedPayloadHashes(transaction);
+  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
+  return elevatedPayloads2;
+}
+__name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
-// src/primitives/summary/transfers/transfersSummary.ts
-import { asAddress as asAddress2, isDefined as isDefined6 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange4 } 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 = asXL1BlockNumber3(isDefined6(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4([
-      rangeStart,
-      headBoundWitness.block
-    ], {
-      name: "transfersSummary"
-    }));
-    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
-    const transfers = {};
-    for (let summary of summaries) {
-      for (const [from, toMap] of Object.entries(summary.transfers)) {
-        const validFrom = asAddress2(from, () => `Invalid address: ${from}`);
-        transfers[validFrom] = transfers[validFrom] ?? {};
-        for (const [to, transfer] of Object.entries(toMap)) {
-          const validTo = asAddress2(to, () => `Invalid address: ${to}`);
-          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer);
-        }
-      }
-    }
-    return transfers;
-  });
+// src/transaction/primitives/transactionRequiredGas.ts
+import { AttoXL1, TransactionGasCosts } from "@xyo-network/xl1-protocol";
+function transactionBytesRequiredGas([transaction, payloads]) {
+  const transactionBlockBytes = transactionBlockByteCount([
+    transaction,
+    payloads
+  ]);
+  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
 }
-__name(transfersSummary, "transfersSummary");
-function transfersSummaryKey(frameHeadHash, frameSize) {
-  return `${frameHeadHash}|${frameSize}`;
+__name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
+function transactionRequiredGas(hydratedTransaction) {
+  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
+  const hashes = elevatedPayloads2.length + 1;
+  const signatures = hydratedTransaction[0].addresses.length;
+  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
 }
-__name(transfersSummaryKey, "transfersSummaryKey");
+__name(transactionRequiredGas, "transactionRequiredGas");
 
-// src/primitives/summary/transfers/transfersStepSummaryFromRange.ts
-async function transfersStepSummaryFromRange(context, range) {
-  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
-  const frameSize = range[1] - range[0] + 1;
-  const [headHash] = await context.head();
-  let result = void 0;
-  if (frameSize === 1) {
-    const hash = await hashFromBlockNumber(context, range[0]);
-    const [, payloads] = await hydrateBlock(context.store, hash);
-    const transfers = {};
-    for (const [from, toMap] of Object.entries(netTransfersForPayloads(payloads))) {
-      transfers[from] = transfers[from] ?? {};
-      for (const [to, amount] of Object.entries(toMap)) {
-        transfers[from][to] = toSignedBigInt(amount);
-      }
+// src/transaction/script.ts
+import { asHash as asHash2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8, 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]);
+  return filterAs(hashes, (h) => asHash2(h));
+}, "tryExtractElevatedHashesFromScript");
+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");
+  return filtered;
+}, "extractElevatedHashesFromScript");
+var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
+  const [bw, payloads] = tx;
+  const { script } = bw;
+  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
+  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
+}, "tryExtractElevatedHashes");
+var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
+  const [bw, payloads] = 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");
+  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";
+async function signTransaction(tx, account) {
+  assertEx9(tx.from === account.address, () => "Signer address does not match transaction from address");
+  const unsignedTx = structuredClone(tx);
+  unsignedTx.addresses = [
+    account.address
+  ];
+  unsignedTx.previous_hashes = [
+    account.previousHash ?? null
+  ];
+  const hash = await PayloadBuilder7.dataHash(unsignedTx);
+  const hashBytes = toArrayBuffer(hash);
+  const [signature] = await account.sign(hashBytes);
+  const result = {
+    ...unsignedTx,
+    $signatures: [
+      hexFromArrayBuffer(signature)
+    ]
+  };
+  return result;
+}
+__name(signTransaction, "signTransaction");
+
+// 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({
+    schema: PayloadBundleSchema2
+  }).fields({
+    payloads,
+    root
+  }).build();
+}, "bundle");
+
+// src/model/Qualified.ts
+import { HashZod } from "@xylabs/sdk-js";
+import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import z from "zod";
+var QualifiedZod = /* @__PURE__ */ __name((zodType) => {
+  return z.tuple([
+    zodType,
+    XL1BlockRangeZod,
+    HashZod
+  ]);
+}, "QualifiedZod");
+
+// src/block/primitives/blockFromBlockNumber.ts
+async function blockFromBlockNumber(context, blockNumber) {
+  const cacheKey = `${blockNumber}`;
+  return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
+    const [headHash] = await context.head();
+    const result = await context.store.chainMap.get(headHash);
+    if (!isDefined6(result)) {
+      throw new Error(`Head block not found for hash: ${headHash}`);
     }
-    result = {
-      schema: TransfersStepSummarySchema,
-      hash: headHash,
-      stepSize: -1,
-      transfers
-    };
-  } else {
-    const step = StepSizes6.indexOf(frameSize);
-    assertEx7(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes6.join(", ")}`);
-    const key = transfersSummaryKey(frameHeadHash, frameSize);
-    const summaryResult = await context.summaryMap.get(key);
-    if (isAnyPayload3(summaryResult)) {
-      result = summaryResult;
-    } else {
-      await context.stepSemaphores[step].acquire();
-      try {
-        const subRanges = deepCalculateFramesFromRange(range, step - 1);
-        const promises = subRanges.map((subRange) => transfersStepSummaryFromRange(context, subRange));
-        const subResults = await Promise.all(promises);
-        const bigIntBalances = {};
-        for (const subResult of subResults) {
-          for (const [from, toMap] of Object.entries(subResult.transfers)) {
-            bigIntBalances[from] = bigIntBalances[from] ?? {};
-            for (const [to, transfer] of Object.entries(toMap)) {
-              bigIntBalances[from][to] = (bigIntBalances[from][to] ?? 0n) + parseSignedBigInt(transfer);
-            }
-          }
-        }
-        const transfers = {};
-        for (const [from, toMap] of Object.entries(bigIntBalances)) {
-          transfers[from] = transfers[from] ?? {};
-          for (const [to, transfer] of Object.entries(toMap)) {
-            transfers[from][to] = toSignedBigInt(transfer);
-          }
+    let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(result, () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`);
+    if (currentBlock.block < blockNumber) {
+      throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
+    }
+    while (currentBlock.block > blockNumber) {
+      let jumpHash = currentBlock.previous;
+      let jumpBlockNumber = currentBlock.block - 1;
+      for (const [step, stepSize2] of StepSizes4.entries()) {
+        const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
+        if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
+          jumpBlockNumber = possibleJumpBlockNumber;
+          jumpHash = asHash3(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
         }
-        result = {
-          schema: TransfersStepSummarySchema,
-          hash: frameHeadHash,
-          stepSize: frameSize,
-          transfers
-        };
-        await context.summaryMap.set(key, result);
-      } finally {
-        context.stepSemaphores[step].release();
+      }
+      const newBlock = await context.store.chainMap.get(asHash3(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
+      if (!isDefined6(newBlock)) {
+        throw new Error(`Block not found for jump hash: ${jumpHash}`);
+      }
+      currentBlock = asSignedBlockBoundWitnessWithStorageMeta(newBlock, () => {
+        const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
+        return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
+      });
+      if (currentBlock.block === blockNumber) {
+        break;
+      }
+      if (currentBlock.block < blockNumber) {
+        throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${headHash}.`);
       }
     }
-  }
-  const finalResult = await PayloadBuilder3.addStorageMeta(result);
-  return finalResult;
+    return currentBlock;
+  });
 }
-__name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
+__name(blockFromBlockNumber, "blockFromBlockNumber");
 
-// src/primitives/timeBudget.ts
-async function timeBudget(name, logger, func, budget, status = false) {
-  const start = Date.now();
-  const timer = status ? setInterval(() => {
-    const duration2 = Date.now() - start;
-    if (budget > 0 && duration2 > budget) {
-      logger?.warn(`Function [${name}] execution is exceeding budget: ${duration2}ms > ${budget}ms`);
-    }
-  }, Math.max(100, budget)) : void 0;
-  const result = await func();
-  const duration = Date.now() - start;
-  if (!timer && budget > 0 && duration > budget) {
-    logger?.warn(`Function [${name}] execution exceeded budget: ${duration}ms > ${budget}ms`);
+// src/block/primitives/frames/calculateFramesFromRange.ts
+import { asXL1BlockNumber, stepSize } from "@xyo-network/xl1-protocol";
+function calculateFramesFromRange(range, step) {
+  const size = stepSize(step);
+  let start = Math.trunc(range[0] / size) * size;
+  const fitted = [];
+  const remaining = [];
+  if (start !== range[0]) {
+    start += size;
+    remaining.push([
+      range[0],
+      asXL1BlockNumber(Math.min(start - 1, range[1]), true)
+    ]);
   }
-  if (timer) {
-    clearInterval(timer);
+  for (let i = start; i <= range[1]; i += size) {
+    if (i + size - 1 <= range[1]) {
+      fitted.push([
+        asXL1BlockNumber(i, {
+          name: "calculateFramesFromRange A"
+        }),
+        asXL1BlockNumber(Math.min(i + size - 1, range[1]), {
+          name: "calculateFramesFromRange B"
+        })
+      ]);
+    } else {
+      remaining.push([
+        asXL1BlockNumber(i, {
+          name: "calculateFramesFromRange C"
+        }),
+        range[1]
+      ]);
+    }
   }
-  return result;
+  return [
+    fitted,
+    remaining
+  ];
 }
-__name(timeBudget, "timeBudget");
+__name(calculateFramesFromRange, "calculateFramesFromRange");
 
-// src/primitives/transaction/elevatedPayloads.ts
-import { isAllowedBlockPayload } from "@xyo-network/xl1-protocol";
-var ELEVATE_OPCODE = "elevate";
-function elevatedPayloads([tx, payloads]) {
-  const opCodes = (tx.script ?? []).filter((operation) => operation.startsWith(`${ELEVATE_OPCODE}|`));
-  const elevatedPayloads2 = [];
-  for (const opCode of opCodes) {
-    const [code, hash] = opCode.split("|");
-    if (code === ELEVATE_OPCODE) {
-      const elevatedPayload = payloads.find((payload) => payload._hash === hash);
-      if (isAllowedBlockPayload(elevatedPayload)) {
-        elevatedPayloads2.push(elevatedPayload);
-      }
+// src/block/primitives/frames/deepCalculateFramesFromRange.ts
+import { StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
+function deepCalculateFramesFromRange(range, startingStep = StepSizes5.length - 1) {
+  const fitted = [];
+  let remaining = [
+    range
+  ];
+  for (let step = startingStep; step >= 0; step--) {
+    const newRemaining = [];
+    for (const range2 of remaining) {
+      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range2, step);
+      fitted.push(...newFittedFrames);
+      newRemaining.push(...newRemainingFrames);
     }
+    remaining = newRemaining;
   }
-  if (opCodes.length === elevatedPayloads2.length) {
-    return elevatedPayloads2;
+  for (const range2 of remaining) {
+    for (let i = range2[0]; i <= range2[1]; i++) {
+      fitted.push([
+        i,
+        i
+      ]);
+    }
   }
-  throw new Error("Not all elevated payloads could be found in the transaction payloads");
+  return fitted.toSorted((a, b) => a[0] - b[0]);
 }
-__name(elevatedPayloads, "elevatedPayloads");
+__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
 
-// src/model/ChainContext/ChainContext.ts
-function contextCache(context, name, create) {
-  if (!context.caches) {
-    context.caches = {};
-  }
-  if (isUndefined(context.caches[name])) {
-    context.caches[name] = create?.() ?? new MemoryMap();
-  }
-  return context.caches[name];
+// src/block/primitives/hashFromBlockNumber.ts
+async function hashFromBlockNumber(context, blockNumber) {
+  return (await blockFromBlockNumber(context, blockNumber))._hash;
 }
-__name(contextCache, "contextCache");
-async function withContextCacheResponse(context, name, key, func, { max = 1e4, timeBudgetMs = 0 } = {}) {
-  const cache = contextCache(context, name, () => new LruCacheMap({
-    max
-  }));
-  const cacheResult = await cache.get(key);
-  if (isDefined7(cacheResult)) {
-    return cacheResult;
-  }
-  const result = timeBudgetMs > 0 ? await timeBudget(name, context.logger, func, timeBudgetMs) : await func();
-  await cache.set(key, result);
-  return result;
+__name(hashFromBlockNumber, "hashFromBlockNumber");
+
+// src/block/primitives/model.ts
+function isReadArchivist(value) {
+  return value.get !== void 0 && value.next !== void 0;
 }
-__name(withContextCacheResponse, "withContextCacheResponse");
+__name(isReadArchivist, "isReadArchivist");
+function isWriteArchivist(value) {
+  return value.insert !== void 0;
+}
+__name(isWriteArchivist, "isWriteArchivist");
+function isReadWriteArchivist(value) {
+  return isReadArchivist(value) && isWriteArchivist(value);
+}
+__name(isReadWriteArchivist, "isReadWriteArchivist");
 
-// src/model/PayloadBundle/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
-var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withHashMeta = await PayloadBuilder4.addHashMeta(payload.payloads);
-  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
-  if (tx) {
-    return [
-      tx,
-      withHashMeta.filter((p) => p._hash !== payload.root)
-    ];
-  }
-}, "bundledPayloadToHydratedTransaction");
+// src/block/primitives/toStepIdentityString.ts
+function toStepIdentityString({ block, step }) {
+  return `${block}|${step}`;
+}
+__name(toStepIdentityString, "toStepIdentityString");
 
-// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
-import { PayloadBundleSchema } from "@xyo-network/payload-model";
+// src/config/Config.ts
+import * as z16 from "zod";
 
-// src/transaction/buildTransaction.ts
-import { assertEx as assertEx8, toHex as toHex2 } from "@xylabs/sdk-js";
-import { BoundWitnessBuilder } from "@xyo-network/boundwitness-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)) {
-    throw new Error("from is required when signer is an array");
-  }
-  const txBoundWitnessFields = {
-    chain,
-    fees: {
-      base: toHex2(fees.base),
-      gasLimit: toHex2(fees.gasLimit),
-      gasPrice: toHex2(fees.gasPrice),
-      priority: toHex2(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder5.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
+// src/config/Api.ts
+import { globalRegistry } from "zod";
+import * as z3 from "zod";
+
+// src/validation/block/error.ts
+import { isValidationError, ValidationError } from "@xyo-network/xl1-protocol";
+var BlockValidationError = class extends ValidationError {
+  static {
+    __name(this, "BlockValidationError");
   }
-  const fields = {
-    ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx8(signer.at(0)?.address) : signer.address)
-  };
-  if (script.length > 0) {
-    fields.script = script;
+};
+var isBlockValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === BlockValidationError.constructor.name;
+}, "isBlockValidationError");
+var HydratedBlockValidationError = class extends ValidationError {
+  static {
+    __name(this, "HydratedBlockValidationError");
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
-    $signatures: []
-  }).payloads([
-    ...onChainPayloads,
-    ...offChainPayloads
-  ]).signers(Array.isArray(signer) ? signer : [
-    signer
-  ]).build();
-  return [
-    await PayloadBuilder5.addHashMeta(tx),
-    await PayloadBuilder5.addHashMeta(txPayloads)
-  ];
-}
-__name(buildTransaction, "buildTransaction");
-
-// src/transaction/buildUnsignedTransaction.ts
-import { toHex as toHex3 } from "@xylabs/sdk-js";
-import { BoundWitnessBuilder as BoundWitnessBuilder2 } from "@xyo-network/boundwitness-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: toHex3(fees.base),
-      gasLimit: toHex3(fees.gasLimit),
-      gasPrice: toHex3(fees.gasPrice),
-      priority: toHex3(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder6.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
+};
+var isHydratedBlockValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedBlockValidationError.constructor.name;
+}, "isHydratedBlockValidationError");
+var HydratedBlockStateValidationError = class extends ValidationError {
+  static {
+    __name(this, "HydratedBlockStateValidationError");
   }
-  const fields = {
-    ...txBoundWitnessFields,
-    from
-  };
-  if (script.length > 0) {
-    fields.script = script;
+  chainId;
+  constructor(hash, chainId, value, message, cause) {
+    super(hash, value, message, cause);
+    this.chainId = chainId;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({
-    $signatures: []
-  }).payloads([
-    ...onChainPayloads,
-    ...offChainPayloads
-  ]).build(false);
-  return [
-    tx,
-    txPayloads
-  ];
-}
-__name(buildUnsignedTransaction, "buildUnsignedTransaction");
-
-// src/transaction/confirmSubmittedTransaction.ts
-import { delay, isDefined as isDefined8 } from "@xylabs/sdk-js";
-var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
-var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
-var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash, options) => {
-  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {};
-  options?.logger?.log("\u{1F680} confirming transaction:", txHash, "\n");
-  let attempts = 0;
-  while (true) {
-    const tx = await viewer.transactionByHash(txHash) ?? void 0;
-    if (isDefined8(tx)) {
-      options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
-      return tx;
-    } else {
-      attempts++;
-      if (attempts > maxAttempts) {
-        options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
-        throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
-      } else {
-        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
-        await delay(attemptDelay);
-      }
-    }
-  }
-}, "confirmSubmittedTransaction");
-
-// src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
-import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
-import { isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
-  return await tryHydrateTypedBoundWitness({
-    get(hashes) {
-      return chainMap.getMany(hashes);
-    },
-    next() {
-      throw new Error("Not implemented");
-    }
-  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
-}, "tryHydrateTransaction");
-var hydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
-  return await hydrateTypedBoundWitness({
-    get(hashes) {
-      return chainMap.getMany(hashes);
-    },
-    next() {
-      throw new Error("Not implemented");
-    }
-  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
-}, "hydrateTransaction");
-var flattenHydratedTransaction = /* @__PURE__ */ __name((hydratedTransaction) => {
-  const [tx, txPayloads] = hydratedTransaction;
-  return [
-    ...txPayloads,
-    tx
-  ];
-}, "flattenHydratedTransaction");
-var flattenHydratedTransactions = /* @__PURE__ */ __name((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
-var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
-  const hydratedTransaction = await tryHydrateTransaction({
-    chainMap
-  }, hash);
-  if (!hydratedTransaction) {
-    return void 0;
-  }
-  const [transaction, payloads] = hydratedTransaction;
-  const opCodes = (transaction.script ?? []).filter((operation) => operation.startsWith("elevate|"));
-  const elevatedPayloads2 = [];
-  for (const opCode of opCodes) {
-    const [code, hash2] = opCode.split("|");
-    if (code === "elevated") {
-      const elevatedPayload = payloads.find((payload) => payload._hash === hash2);
-      if (isAllowedBlockPayload2(elevatedPayload)) {
-        elevatedPayloads2.push(elevatedPayload);
-      }
-    }
-  }
-  if (opCodes.length === elevatedPayloads2.length) {
-    return [
-      transaction,
-      elevatedPayloads2
-    ];
-  }
-  return void 0;
-}, "tryHydrateElevatedTransaction");
-var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx9(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
-}, "hydrateElevatedTransaction");
-
-// src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
-function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder7.omitStorageMeta(transaction);
-  const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder7.omitStorageMeta(payloads);
-  return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
-}
-__name(transactionBlockByteCount, "transactionBlockByteCount");
-
-// src/transaction/primitives/transactionElevatedPayloads.ts
-import { asHash } from "@xylabs/sdk-js";
-
-// src/transaction/primitives/transactionOperations.ts
-function crackOperation(operation) {
-  const parts = operation.split("|");
-  if (parts.length < 2) {
-    throw new Error(`Invalid operation format: ${operation}`);
-  }
-  return [
-    parts[0],
-    parts.slice(1)
-  ];
-}
-__name(crackOperation, "crackOperation");
-function crackOperations(operations) {
-  return operations.map((op) => crackOperation(op));
-}
-__name(crackOperations, "crackOperations");
-
-// src/transaction/primitives/transactionElevatedPayloads.ts
-function transactionElevatedPayloadHashes(transaction) {
-  const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
-  return elevateOperations.map((op) => asHash(op[1][0], true));
-}
-__name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
-function transactionElevatedPayloads([transaction, payloads]) {
-  const hashes = transactionElevatedPayloadHashes(transaction);
-  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
-  return elevatedPayloads2;
-}
-__name(transactionElevatedPayloads, "transactionElevatedPayloads");
-
-// src/transaction/primitives/transactionRequiredGas.ts
-import { AttoXL1, TransactionGasCosts } from "@xyo-network/xl1-protocol";
-function transactionBytesRequiredGas([transaction, payloads]) {
-  const transactionBlockBytes = transactionBlockByteCount([
-    transaction,
-    payloads
-  ]);
-  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
-}
-__name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
-function transactionRequiredGas(hydratedTransaction) {
-  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
-  const hashes = elevatedPayloads2.length + 1;
-  const signatures = hydratedTransaction[0].addresses.length;
-  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
-}
-__name(transactionRequiredGas, "transactionRequiredGas");
-
-// src/transaction/script.ts
-import { asHash as asHash2 } from "@xylabs/sdk-js";
-import { assertEx as assertEx10, 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]);
-  return filterAs(hashes, (h) => asHash2(h));
-}, "tryExtractElevatedHashesFromScript");
-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));
-  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
-  return filtered;
-}, "extractElevatedHashesFromScript");
-var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
-  const [bw, payloads] = tx;
-  const { script } = bw;
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-}, "tryExtractElevatedHashes");
-var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
-  const [bw, payloads] = tx;
-  const { script } = bw;
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
-  return filtered;
-}, "extractElevatedHashes");
-
-// src/transaction/signTransaction.ts
-import { assertEx as assertEx11, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
-async function signTransaction(tx, account) {
-  assertEx11(tx.from === account.address, () => "Signer address does not match transaction from address");
-  const unsignedTx = structuredClone(tx);
-  unsignedTx.addresses = [
-    account.address
-  ];
-  unsignedTx.previous_hashes = [
-    account.previousHash ?? null
-  ];
-  const hash = await PayloadBuilder8.dataHash(unsignedTx);
-  const hashBytes = toArrayBuffer(hash);
-  const [signature] = await account.sign(hashBytes);
-  const result = {
-    ...unsignedTx,
-    $signatures: [
-      hexFromArrayBuffer(signature)
-    ]
-  };
-  return result;
-}
-__name(signTransaction, "signTransaction");
-
-// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
-var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
-  const root = transaction[0]._hash;
-  return bundle(root, transaction);
-}, "hydratedTransactionToPayloadBundle");
-var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder9.omitStorageMeta(p));
-  return new PayloadBuilder9({
-    schema: PayloadBundleSchema
-  }).fields({
-    payloads,
-    root
-  }).build();
-}, "bundle");
-
-// src/block/primitives/blockFromBlockNumber.ts
-async function blockFromBlockNumber(context, blockNumber) {
-  const cacheKey = `${blockNumber}`;
-  return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
-    const [headHash] = await context.head();
-    const result = await context.store.chainMap.get(headHash);
-    if (!isDefined9(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)}`);
-    if (currentBlock.block < blockNumber) {
-      throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
-    }
-    while (currentBlock.block > blockNumber) {
-      let jumpHash = currentBlock.previous;
-      let jumpBlockNumber = currentBlock.block - 1;
-      for (const [step, stepSize2] of StepSizes7.entries()) {
-        const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
-        if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
-          jumpBlockNumber = possibleJumpBlockNumber;
-          jumpHash = asHash3(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
-        }
-      }
-      const newBlock = await context.store.chainMap.get(asHash3(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
-      if (!isDefined9(newBlock)) {
-        throw new Error(`Block not found for jump hash: ${jumpHash}`);
-      }
-      currentBlock = asSignedBlockBoundWitnessWithStorageMeta(newBlock, () => {
-        const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
-        return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
-      });
-      if (currentBlock.block === blockNumber) {
-        break;
-      }
-      if (currentBlock.block < blockNumber) {
-        throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${headHash}.`);
-      }
-    }
-    return currentBlock;
-  });
-}
-__name(blockFromBlockNumber, "blockFromBlockNumber");
-
-// src/block/primitives/frames/calculateFramesFromRange.ts
-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;
-  const fitted = [];
-  const remaining = [];
-  if (start !== range[0]) {
-    start += size;
-    remaining.push([
-      range[0],
-      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([
-        asXL1BlockNumber4(i, {
-          name: "calculateFramesFromRange A"
-        }),
-        asXL1BlockNumber4(Math.min(i + size - 1, range[1]), {
-          name: "calculateFramesFromRange B"
-        })
-      ]);
-    } else {
-      remaining.push([
-        asXL1BlockNumber4(i, {
-          name: "calculateFramesFromRange C"
-        }),
-        range[1]
-      ]);
-    }
-  }
-  return [
-    fitted,
-    remaining
-  ];
-}
-__name(calculateFramesFromRange, "calculateFramesFromRange");
-
-// src/block/primitives/frames/deepCalculateFramesFromRange.ts
-import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
-function deepCalculateFramesFromRange(range, startingStep = StepSizes8.length - 1) {
-  const fitted = [];
-  let remaining = [
-    range
-  ];
-  for (let step = startingStep; step >= 0; step--) {
-    const newRemaining = [];
-    for (const range2 of remaining) {
-      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range2, step);
-      fitted.push(...newFittedFrames);
-      newRemaining.push(...newRemainingFrames);
-    }
-    remaining = newRemaining;
-  }
-  for (const range2 of remaining) {
-    for (let i = range2[0]; i <= range2[1]; i++) {
-      fitted.push([
-        i,
-        i
-      ]);
-    }
-  }
-  return fitted.toSorted((a, b) => a[0] - b[0]);
-}
-__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
-
-// src/block/primitives/hashFromBlockNumber.ts
-async function hashFromBlockNumber(context, blockNumber) {
-  return (await blockFromBlockNumber(context, blockNumber))._hash;
-}
-__name(hashFromBlockNumber, "hashFromBlockNumber");
-
-// src/block/primitives/model.ts
-function isReadArchivist(value) {
-  return value.get !== void 0 && value.next !== void 0;
-}
-__name(isReadArchivist, "isReadArchivist");
-function isWriteArchivist(value) {
-  return value.insert !== void 0;
-}
-__name(isWriteArchivist, "isWriteArchivist");
-function isReadWriteArchivist(value) {
-  return isReadArchivist(value) && isWriteArchivist(value);
-}
-__name(isReadWriteArchivist, "isReadWriteArchivist");
-
-// src/block/primitives/toStepIdentityString.ts
-function toStepIdentityString({ block, step }) {
-  return `${block}|${step}`;
-}
-__name(toStepIdentityString, "toStepIdentityString");
-
-// src/config/Config.ts
-import * as z15 from "zod";
-
-// src/config/Api.ts
-import { globalRegistry } from "zod";
-import * as z2 from "zod";
-
-// src/validation/block/error.ts
-import { isValidationError, ValidationError } from "@xyo-network/xl1-protocol";
-var BlockValidationError = class extends ValidationError {
-  static {
-    __name(this, "BlockValidationError");
-  }
-};
-var isBlockValidationError = /* @__PURE__ */ __name((error) => {
-  if (!isValidationError(error)) return false;
-  return error.name === BlockValidationError.constructor.name;
-}, "isBlockValidationError");
-var HydratedBlockValidationError = class extends ValidationError {
-  static {
-    __name(this, "HydratedBlockValidationError");
-  }
-};
-var isHydratedBlockValidationError = /* @__PURE__ */ __name((error) => {
-  if (!isValidationError(error)) return false;
-  return error.name === HydratedBlockValidationError.constructor.name;
-}, "isHydratedBlockValidationError");
-var HydratedBlockStateValidationError = class extends ValidationError {
-  static {
-    __name(this, "HydratedBlockStateValidationError");
-  }
-  chainId;
-  constructor(hash, chainId, value, message, cause) {
-    super(hash, value, message, cause);
-    this.chainId = chainId;
-  }
-};
-var isHydratedBlockStateValidationError = /* @__PURE__ */ __name((error) => {
-  if (!isValidationError(error)) return false;
-  return error.name === HydratedBlockStateValidationError.constructor.name;
-}, "isHydratedBlockStateValidationError");
+};
+var isHydratedBlockStateValidationError = /* @__PURE__ */ __name((error) => {
+  if (!isValidationError(error)) return false;
+  return error.name === HydratedBlockStateValidationError.constructor.name;
+}, "isHydratedBlockStateValidationError");
 
 // src/validation/lib/isLocalhost.ts
 var isLocalhost = /* @__PURE__ */ __name((hostname) => {
@@ -1323,8 +978,8 @@ var getUrl = /* @__PURE__ */ __name((host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import * as z from "zod";
-var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine((s) => [
+import * as z2 from "zod";
+var MnemonicStringZod = z2.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine((s) => [
   12,
   15,
   18,
@@ -1335,16 +990,16 @@ var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g,
 }).describe("BIP-39 mnemonic string");
 
 // src/config/Api.ts
-var ApiConfigZod = z2.object({
-  host: z2.string().default("localhost").register(globalRegistry, {
+var ApiConfigZod = z3.object({
+  host: z3.string().default("localhost").register(globalRegistry, {
     default: "localhost",
     description: "Host for the API",
     title: "api.host",
     type: "string"
   }),
-  initRewardsCache: z2.union([
-    z2.number(),
-    z2.string()
+  initRewardsCache: z3.union([
+    z3.number(),
+    z3.string()
   ]).transform((v) => v !== "0" && v !== "false").default(true).register(globalRegistry, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
@@ -1355,7 +1010,7 @@ var ApiConfigZod = z2.object({
     title: "api.mnemonic",
     type: "string"
   }),
-  port: z2.coerce.number().default(8080).register(globalRegistry, {
+  port: z3.coerce.number().default(8080).register(globalRegistry, {
     default: 8080,
     description: "Port for the API",
     title: "api.port",
@@ -1365,9 +1020,9 @@ var ApiConfigZod = z2.object({
 
 // src/config/Bridge.ts
 import { globalRegistry as globalRegistry2 } from "zod";
-import * as z3 from "zod";
-var BridgeConfigZod = z3.object({
-  host: z3.string().default("localhost").register(globalRegistry2, {
+import * as z4 from "zod";
+var BridgeConfigZod = z4.object({
+  host: z4.string().default("localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge",
     title: "api.host",
@@ -1378,7 +1033,7 @@ var BridgeConfigZod = z3.object({
     title: "api.mnemonic",
     type: "string"
   }),
-  port: z3.coerce.number().default(8081).register(globalRegistry2, {
+  port: z4.coerce.number().default(8081).register(globalRegistry2, {
     default: 8081,
     description: "Port for the Bridge",
     title: "api.port",
@@ -1389,9 +1044,9 @@ var BridgeConfigZod = z3.object({
 // src/config/Chain.ts
 import { AddressZod } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry3 } from "zod";
-import * as z4 from "zod";
-var ChainConfigZod = z4.object({
-  id: z4.string().optional().register(globalRegistry3, {
+import * as z5 from "zod";
+var ChainConfigZod = z5.object({
+  id: z5.string().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"
@@ -1405,28 +1060,28 @@ var ChainConfigZod = z4.object({
 
 // src/config/Evm.ts
 import { globalRegistry as globalRegistry4 } from "zod";
-import * as z5 from "zod";
-var EvmInfuraConfigZod = z5.object({
-  projectId: z5.string().optional().register(globalRegistry4, {
+import * as z6 from "zod";
+var EvmInfuraConfigZod = z6.object({
+  projectId: z6.string().optional().register(globalRegistry4, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z5.string().optional().register(globalRegistry4, {
+  projectSecret: z6.string().optional().register(globalRegistry4, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z5.object({
-  url: z5.url().optional().register(globalRegistry4, {
+var EvmJsonRpcConfigZod = z6.object({
+  url: z6.url().optional().register(globalRegistry4, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z5.object({
-  chainId: z5.string().optional().register(globalRegistry4, {
+var EvmConfigZod = z6.object({
+  chainId: z6.string().optional().register(globalRegistry4, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -1438,17 +1093,17 @@ var EvmConfigZod = z5.object({
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry5 } from "zod";
-import * as z6 from "zod";
+import * as z7 from "zod";
 var LogLevels = Object.keys(LogLevel);
-var LogConfigZod = z6.object({
-  logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
+var LogConfigZod = z7.object({
+  logLevel: z7.enum(LogLevels).default("info").register(globalRegistry5, {
     choices: LogLevels,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z6.boolean().default(false).register(globalRegistry5, {
+  silent: z7.boolean().default(false).register(globalRegistry5, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1458,9 +1113,9 @@ var LogConfigZod = z6.object({
 
 // src/config/Mempool.ts
 import { globalRegistry as globalRegistry6 } from "zod";
-import * as z7 from "zod";
-var MempoolConfigZod = z7.object({
-  enabled: z7.string().default("false").transform((val, ctx) => {
+import * as z8 from "zod";
+var MempoolConfigZod = z8.object({
+  enabled: z8.string().default("false").transform((val, ctx) => {
     const normalized = val.toLowerCase().trim();
     if ([
       "true",
@@ -1479,14 +1134,14 @@ var MempoolConfigZod = z7.object({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z7.NEVER;
+    return z8.NEVER;
   }).register(globalRegistry6, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  host: z7.string().default("localhost").register(globalRegistry6, {
+  host: z8.string().default("localhost").register(globalRegistry6, {
     default: "localhost",
     description: "Host for the Mempool",
     title: "mempool.host",
@@ -1497,7 +1152,7 @@ var MempoolConfigZod = z7.object({
     title: "mempool.mnemonic",
     type: "string"
   }),
-  port: z7.coerce.number().default(8083).register(globalRegistry6, {
+  port: z8.coerce.number().default(8083).register(globalRegistry6, {
     default: 8083,
     description: "Port for the Mempool",
     title: "mempool.port",
@@ -1506,38 +1161,38 @@ var MempoolConfigZod = z7.object({
 });
 
 // src/config/Producer.ts
-import { AddressZod as AddressZod2, asAddress as asAddress3 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry7 } from "zod";
-import * as z8 from "zod";
-var ProducerConfigZod = z8.object({
-  allowlist: z8.preprocess((val) => {
+import * as z9 from "zod";
+var ProducerConfigZod = z9.object({
+  allowlist: z9.preprocess((val) => {
     if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress3(s.trim()));
+      return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z8.array(AddressZod2).optional().register(globalRegistry7, {
+  }, z9.array(AddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  disableIntentRedeclaration: z8.boolean().optional().register(globalRegistry7, {
+  disableIntentRedeclaration: z9.boolean().optional().register(globalRegistry7, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
   // TODO: Port schema
-  healthCheckPort: z8.coerce.number().optional().register(globalRegistry7, {
+  healthCheckPort: z9.coerce.number().optional().register(globalRegistry7, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
   }),
-  heartbeatInterval: z8.coerce.number().default(36e5).register(globalRegistry7, {
+  heartbeatInterval: z9.coerce.number().default(36e5).register(globalRegistry7, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z8.coerce.number().default(1).register(globalRegistry7, {
+  minStake: z9.coerce.number().default(1).register(globalRegistry7, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
@@ -1548,14 +1203,14 @@ var ProducerConfigZod = z8.object({
     type: "string"
   }),
   // TODO: Port schema
-  port: z8.coerce.number().default(8081).register(globalRegistry7, {
+  port: z9.coerce.number().default(8081).register(globalRegistry7, {
     default: 8081,
     description: "Port for the Producer",
     title: "producer.port",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z8.string().optional().register(globalRegistry7, {
+  rewardAddress: z9.string().optional().register(globalRegistry7, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -1564,15 +1219,15 @@ var ProducerConfigZod = z8.object({
 
 // src/config/RewardRedemptionApi.ts
 import { globalRegistry as globalRegistry8 } from "zod";
-import * as z9 from "zod";
-var RewardRedemptionApiConfigZod = z9.object({
-  chainRpcApiUrl: z9.string().default("http://localhost:8080/rpc").register(globalRegistry8, {
+import * as z10 from "zod";
+var RewardRedemptionApiConfigZod = z10.object({
+  chainRpcApiUrl: z10.string().default("http://localhost:8080/rpc").register(globalRegistry8, {
     default: "http://localhost:8080/rpc",
     description: "URL for the Chain RPC API",
     title: "rewardRedemptionApi.chainRpcApiUrl",
     type: "string"
   }),
-  host: z9.string().default("localhost").register(globalRegistry8, {
+  host: z10.string().default("localhost").register(globalRegistry8, {
     default: "localhost",
     description: "Host for the Redemption API",
     title: "rewardRedemptionApi.host",
@@ -1583,7 +1238,7 @@ var RewardRedemptionApiConfigZod = z9.object({
     title: "rewardRedemptionApi.mnemonic",
     type: "string"
   }),
-  port: z9.coerce.number().default(8082).register(globalRegistry8, {
+  port: z10.coerce.number().default(8082).register(globalRegistry8, {
     default: 8082,
     description: "Port for the Redemption API",
     title: "rewardRedemptionApi.port",
@@ -1593,14 +1248,14 @@ var RewardRedemptionApiConfigZod = z9.object({
 
 // src/config/Services.ts
 import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
-var ServicesConfigZod = z10.object({
-  accountBalanceViewerEndpoint: z10.string().optional().register(globalRegistry9, {
+import * as z11 from "zod";
+var ServicesConfigZod = z11.object({
+  accountBalanceViewerEndpoint: z11.string().optional().register(globalRegistry9, {
     description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
     title: "services.accountBalanceViewerEndpoint",
     type: "string"
   }),
-  apiEndpoint: z10.string().optional().register(globalRegistry9, {
+  apiEndpoint: z11.string().optional().register(globalRegistry9, {
     description: "Endpoint of the API to use for instantiating an external Viewers",
     title: "services.apiEndpoint",
     type: "string"
@@ -1608,36 +1263,36 @@ var ServicesConfigZod = z10.object({
 });
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined10, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined7, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry10 } from "zod";
-import * as z11 from "zod";
+import * as z12 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined2(config)) return false;
-  return isDefined10(config.connectionString) && isDefined10(config.database) && isDefined10(config.domain) && isDefined10(config.password) && isDefined10(config.username);
+  return isDefined7(config.connectionString) && isDefined7(config.database) && isDefined7(config.domain) && isDefined7(config.password) && isDefined7(config.username);
 }, "hasMongoConfig");
-var MongoConfigZod = z11.object({
+var MongoConfigZod = z12.object({
   // TODO: Create from other arguments
-  connectionString: z11.string().nonempty().optional().register(globalRegistry10, {
+  connectionString: z12.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z11.string().nonempty().optional().register(globalRegistry10, {
+  database: z12.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z11.string().nonempty().optional().register(globalRegistry10, {
+  domain: z12.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z11.string().nonempty().optional().register(globalRegistry10, {
+  password: z12.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z11.string().nonempty().optional().register(globalRegistry10, {
+  username: z12.string().nonempty().optional().register(globalRegistry10, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -1646,10 +1301,10 @@ var MongoConfigZod = z11.object({
 
 // src/config/storage/Storage.ts
 import { globalRegistry as globalRegistry11 } from "zod";
-import * as z12 from "zod";
-var StorageConfigZod = z12.object({
+import * as z13 from "zod";
+var StorageConfigZod = z13.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z12.string().optional().register(globalRegistry11, {
+  root: z13.string().optional().register(globalRegistry11, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -1658,33 +1313,33 @@ var StorageConfigZod = z12.object({
 
 // src/config/Telemetry.ts
 import { globalRegistry as globalRegistry12 } from "zod";
-import * as z13 from "zod";
-var MetricsScrapeConfigZod = z13.object({
-  path: z13.string().default("/metrics").register(globalRegistry12, {
+import * as z14 from "zod";
+var MetricsScrapeConfigZod = z14.object({
+  path: z14.string().default("/metrics").register(globalRegistry12, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z13.coerce.number().default(9464).register(globalRegistry12, {
+  port: z14.coerce.number().default(9464).register(globalRegistry12, {
     default: 9464,
     description: "Port for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z13.object({
+var MetricsConfigZod = z14.object({
   scrape: MetricsScrapeConfigZod
 }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z13.object({
+var OpenTelemetryConfigZod = z14.object({
   // OpenTelemetry options
-  otlpEndpoint: z13.url().optional().register(globalRegistry12, {
+  otlpEndpoint: z14.url().optional().register(globalRegistry12, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z13.object({
+var TelemetryConfigZod = z14.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -1692,26 +1347,26 @@ var TelemetryConfigZod = z13.object({
 }).describe("Telemetry configuration options");
 
 // src/config/Validation.ts
-import { AddressZod as AddressZod3, asAddress as asAddress4 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod3, asAddress as asAddress2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry13 } from "zod";
-import * as z14 from "zod";
-var ValidationConfigZod = z14.object({
-  allowedRewardRedeemers: z14.preprocess((val) => {
+import * as z15 from "zod";
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.preprocess((val) => {
     if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress4(s.trim()));
+      return val.split(",").map((s) => asAddress2(s.trim()));
     }
     return val;
-  }, z14.array(AddressZod3).optional().register(globalRegistry13, {
+  }, z15.array(AddressZod3).optional().register(globalRegistry13, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   })),
-  allowedRewardEscrowAccountSigners: z14.preprocess((val) => {
+  allowedRewardEscrowAccountSigners: z15.preprocess((val) => {
     if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress4(s.trim()));
+      return val.split(",").map((s) => asAddress2(s.trim()));
     }
     return val;
-  }, z14.array(AddressZod3).optional().register(globalRegistry13, {
+  }, z15.array(AddressZod3).optional().register(globalRegistry13, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
@@ -1719,10 +1374,10 @@ var ValidationConfigZod = z14.object({
 });
 
 // src/config/Config.ts
-var Xl1CommonConfigSchema = z15.object({
+var Xl1CommonConfigSchema = z16.object({
   ...LogConfigZod.shape
 }).describe("XL1 common configuration options");
-var ConfigZod = z15.object({
+var ConfigZod = z16.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
   bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).describe("Configuration for the Bridge node"),
@@ -1739,35 +1394,35 @@ var ConfigZod = z15.object({
 var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
 
 // src/config/UsageMeta.ts
-import * as z16 from "zod";
-var DescriptionSchema = z16.string();
-var TitleSchema = z16.string();
-var JSONSchemaMetaSchema = z16.object({
-  id: z16.string().optional(),
+import * as z17 from "zod";
+var DescriptionSchema = z17.string();
+var TitleSchema = z17.string();
+var JSONSchemaMetaSchema = z17.object({
+  id: z17.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z16.boolean().optional()
-}).catchall(z16.unknown());
+  deprecated: z17.boolean().optional()
+}).catchall(z17.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z16.array(z16.union([
-  z16.string(),
-  z16.number(),
-  z16.literal(true),
-  z16.undefined()
+var ChoicesSchema = z17.array(z17.union([
+  z17.string(),
+  z17.number(),
+  z17.literal(true),
+  z17.undefined()
 ])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z16.unknown().optional(),
+  default: z17.unknown().optional(),
   description: DescriptionSchema,
-  group: z16.string().optional(),
-  hidden: z16.boolean().optional(),
+  group: z17.string().optional(),
+  hidden: z17.boolean().optional(),
   title: TitleSchema,
-  type: z16.union([
-    z16.literal("array"),
-    z16.literal("count"),
-    z16.literal("boolean"),
-    z16.literal("number"),
-    z16.literal("string")
+  type: z17.union([
+    z17.literal("array"),
+    z17.literal("count"),
+    z17.literal("boolean"),
+    z17.literal("number"),
+    z17.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -1775,116 +1430,585 @@ 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/constants.ts
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH = 1760572800;
+var XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK = 107496;
+
+// src/eip-712/Payloads/EIP712Data.ts
+import { AsObjectFactory } from "@xylabs/sdk-js";
+import { isPayloadOfZodType } from "@xyo-network/payload-model";
+import z19 from "zod";
+
+// src/eip-712/Types.ts
+import z18 from "zod";
+var TypedDataDomainZod = z18.object({
+  name: z18.string().nullable().optional(),
+  version: z18.string().nullable().optional(),
+  chainId: z18.union([
+    z18.string(),
+    z18.number(),
+    z18.bigint()
+  ]).nullable().optional(),
+  verifyingContract: z18.string().nullable().optional(),
+  salt: z18.union([
+    z18.string(),
+    z18.instanceof(Uint8Array)
+  ]).nullable().optional()
+});
+var TypedDataFieldZod = z18.object({
+  name: z18.string(),
+  type: z18.string()
+});
+var TypedDataTypesZod = z18.record(z18.string(), z18.array(TypedDataFieldZod));
+var TypedDataValueZod = z18.record(z18.string(), z18.any());
+
+// src/eip-712/Payloads/EIP712Data.ts
+var EIP712DataPayloadFieldsZod = z19.object({
+  domain: TypedDataDomainZod,
+  types: TypedDataTypesZod,
+  values: TypedDataValueZod
+});
+var EIP712DataPayloadSchema = "network.xyo.chains.ethereum.eip712.data";
+var isEIP712DataPayload = isPayloadOfZodType(EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema);
+var asEIP712DataPayload = AsObjectFactory.create(isEIP712DataPayload);
+
+// src/eip-712/Payloads/EIP712Signature.ts
+import { AsObjectFactory as AsObjectFactory2, HashZod as HashZod2 } from "@xylabs/sdk-js";
+import { isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/payload-model";
+import z20 from "zod";
+var EIP712SignaturePayloadFieldsZod = z20.object({
+  address: z20.string(),
+  hash: HashZod2,
+  signature: z20.string()
+});
+var EIP712SignaturePayloadSchema = "network.xyo.chains.ethereum.eip712.signature";
+var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema);
+var asEIP712SignaturePayload = AsObjectFactory2.create(isEIP712SignaturePayload);
+
+// src/eip-712/sign.ts
+import { PayloadBuilder as PayloadBuilder9 } 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 address = await signer.getAddress();
+  return {
+    address,
+    hash,
+    schema: EIP712SignaturePayloadSchema,
+    signature
+  };
+}, "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 { 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;
+  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);
+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}`]: [
+    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS,
+    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS
+  ]
+};
+
+// 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 toAddress3 } from "@xylabs/sdk-js";
+import { span } from "@xylabs/telemetry";
+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[toAddress3(address)] = (balances[toAddress3(address)] ?? 0n) + hexToBigInt(amount);
+          balances[toAddress3(from)] = (balances[toAddress3(from)] ?? 0n) - hexToBigInt(amount);
+        }
+      }
+    }
+    return balances;
+  });
+}, "netBalancesForPayloads");
+
+// src/payloads/netSchemasForPayloads.ts
+import { hexToBigInt as hexToBigInt2, toAddress as toAddress4 } from "@xylabs/sdk-js";
+import { span as span2 } from "@xylabs/telemetry";
+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[toAddress4(address)] = (balances[toAddress4(address)] ?? 0n) + hexToBigInt2(amount);
+          balances[toAddress4(from)] = (balances[toAddress4(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/telemetry";
+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/services/StakeIntentService/ChainIndexingServiceStateSchema.ts
+import { AsObjectFactory as AsObjectFactory4 } from "@xylabs/sdk-js";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2, isStorageMeta } from "@xyo-network/payload-model";
+var ChainIndexingServiceStateSchema = "network.xyo.chain.indexing.service.state";
+var isChainIndexingServiceState = /* @__PURE__ */ __name((payload) => {
+  return isPayloadOfSchemaType2(ChainIndexingServiceStateSchema)(payload);
+}, "isChainIndexingServiceState");
+var asChainIndexingServiceState = AsObjectFactory4.create(isChainIndexingServiceState);
+var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta(value), "isChainIndexingServiceStateWithStorageMeta");
+var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory4.create(isChainIndexingServiceStateWithStorageMeta);
+
+// src/SignedBigInt.ts
+import { hexToBigInt as hexToBigInt4, toHex as toHex3 } 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";
+}, "isNegativeBigInt");
+var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
+  return isObject(value) && "positive" in value && typeof value.positive === "string";
+}, "isPositiveBigInt");
+var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
+  if (isNegativeBigInt(value)) {
+    return -hexToBigInt4(value.negative);
+  } else if (isPositiveBigInt(value)) {
+    return hexToBigInt4(value.positive);
+  } else {
+    throw new Error("Invalid balance type");
+  }
+}, "parseSignedBigInt");
+var toSignedBigInt = /* @__PURE__ */ __name((value) => {
+  return value < 0n ? {
+    negative: toHex3(-value)
+  } : {
+    positive: toHex3(value)
+  };
+}, "toSignedBigInt");
+var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
+  if (isNegativeBigInt(value)) {
+    return {
+      positive: toHex3(0n)
+    };
+  }
+  if (isPositiveBigInt(value)) {
+    return {
+      positive: value.positive
+    };
+  }
+  if (typeof value === "bigint") {
+    return {
+      positive: toHex3(value)
+    };
+  }
+  throw new Error("Invalid value for positive big int");
+}, "toPositiveBigInt");
+
+// src/simple/accountBalance/SimpleAccountBalanceViewer.ts
+import { AbstractCreatable, asHash as asHash5, assertEx as assertEx13, exists, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange5, AttoXL1 as AttoXL12, StepSizes as StepSizes9, TransferSchema } from "@xyo-network/xl1-protocol";
 
-// src/eip-712/Payloads/EIP712Data.ts
+// src/summary/model/BalancesStepSummary.ts
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
-import { isPayloadOfZodType } from "@xyo-network/payload-model";
-import z18 from "zod";
-
-// src/eip-712/Types.ts
-import z17 from "zod";
-var TypedDataDomainZod = z17.object({
-  name: z17.string().nullable().optional(),
-  version: z17.string().nullable().optional(),
-  chainId: z17.union([
-    z17.string(),
-    z17.number(),
-    z17.bigint()
-  ]).nullable().optional(),
-  verifyingContract: z17.string().nullable().optional(),
-  salt: z17.union([
-    z17.string(),
-    z17.instanceof(Uint8Array)
-  ]).nullable().optional()
-});
-var TypedDataFieldZod = z17.object({
-  name: z17.string(),
-  type: z17.string()
-});
-var TypedDataTypesZod = z17.record(z17.string(), z17.array(TypedDataFieldZod));
-var TypedDataValueZod = z17.record(z17.string(), z17.any());
+import { isPayloadOfSchemaType as isPayloadOfSchemaType3, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
+var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
+var isBalancesStepSummary = isPayloadOfSchemaType3(BalancesStepSummarySchema);
+var asBalancesStepSummary = AsObjectFactory5.create(isBalancesStepSummary);
+var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
+  return isBalancesStepSummary(value) && isStorageMeta2(value);
+}, "isBalancesStepSummaryWithStorageMeta");
+var asBalancesStepSummaryWithStorageMeta = AsObjectFactory5.create(isBalancesStepSummaryWithStorageMeta);
 
-// src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z18.object({
-  domain: TypedDataDomainZod,
-  types: TypedDataTypesZod,
-  values: TypedDataValueZod
-});
-var EIP712DataPayloadSchema = "network.xyo.chains.ethereum.eip712.data";
-var isEIP712DataPayload = isPayloadOfZodType(EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema);
-var asEIP712DataPayload = AsObjectFactory5.create(isEIP712DataPayload);
+// src/summary/model/SchemasStepSummary.ts
+import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType4, isStorageMeta as isStorageMeta3 } from "@xyo-network/payload-model";
+var SchemasStepSummarySchema = "network.xyo.step.summary.schemas";
+var isSchemasStepSummary = isPayloadOfSchemaType4(SchemasStepSummarySchema);
+var asSchemasStepSummary = AsObjectFactory6.create(isSchemasStepSummary);
+var isSchemasStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
+  return isSchemasStepSummary(value) && isStorageMeta3(value);
+}, "isSchemasStepSummaryWithStorageMeta");
+var asSchemasStepSummaryWithStorageMeta = AsObjectFactory6.create(isSchemasStepSummaryWithStorageMeta);
 
-// src/eip-712/Payloads/EIP712Signature.ts
-import { AsObjectFactory as AsObjectFactory6, HashZod } from "@xylabs/sdk-js";
-import { isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/payload-model";
-import z19 from "zod";
-var EIP712SignaturePayloadFieldsZod = z19.object({
-  address: z19.string(),
-  hash: HashZod,
-  signature: z19.string()
-});
-var EIP712SignaturePayloadSchema = "network.xyo.chains.ethereum.eip712.signature";
-var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema);
-var asEIP712SignaturePayload = AsObjectFactory6.create(isEIP712SignaturePayload);
+// src/summary/model/StepSummary.ts
+var StepSummarySchema = "network.xyo.step.summary";
 
-// src/eip-712/sign.ts
-import { PayloadBuilder as PayloadBuilder10 } 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 PayloadBuilder10.hash(data);
-  const address = await signer.getAddress();
-  return {
-    address,
-    hash,
-    schema: EIP712SignaturePayloadSchema,
-    signature
-  };
-}, "signEIP712Message");
+// src/summary/model/TransfersSummary.ts
+import { AsObjectFactory as AsObjectFactory7 } from "@xylabs/sdk-js";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType5, isStorageMeta as isStorageMeta4 } from "@xyo-network/payload-model";
+var TransfersStepSummarySchema = "network.xyo.step.summary.transfer";
+var isTransfersStepSummary = isPayloadOfSchemaType5(TransfersStepSummarySchema);
+var asTransfersStepSummary = AsObjectFactory7.create(isTransfersStepSummary);
+var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
+  return isTransfersStepSummary(value) && isStorageMeta4(value);
+}, "isTransfersStepSummaryWithStorageMeta");
+var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersStepSummaryWithStorageMeta);
 
-// src/eip-712/verify.ts
-import { asHash as asHash4, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+// src/summary/primitives/balances/balancesStepSummaryFromRange.ts
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder11 } 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 PayloadBuilder11.hash(data)) return false;
-  const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
-  return recoveredAddress.toLowerCase() === address.toLowerCase();
-}, "verifyEIP712Message");
+import { isAnyPayload } from "@xyo-network/payload-model";
+import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
+async function balancesStepSummaryFromRange(context, range) {
+  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
+  const frameSize = range[1] - range[0] + 1;
+  const [headHash] = await context.head();
+  let result = void 0;
+  if (frameSize === 1) {
+    const hash = await hashFromBlockNumber(context, range[0]);
+    const [, payloads] = await hydrateBlock(context.store, hash);
+    const balances = {};
+    for (const [address, balance] of Object.entries(netBalancesForPayloads(payloads))) {
+      balances[address] = toSignedBigInt(balance);
+    }
+    result = {
+      schema: BalancesStepSummarySchema,
+      hash: headHash,
+      stepSize: -1,
+      balances
+    };
+  } else {
+    const step = StepSizes6.indexOf(frameSize);
+    assertEx10(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes6.join(", ")}`);
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
+    if (isAnyPayload(summaryResult)) {
+      result = summaryResult;
+    } else {
+      await context.stepSemaphores[step].acquire();
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1);
+        const promises = subRanges.map((subRange) => balancesStepSummaryFromRange(context, subRange));
+        const subResults = await Promise.all(promises);
+        const bigIntBalances = {};
+        for (const subResult of subResults) {
+          for (const [address, balance] of Object.entries(subResult.balances)) {
+            bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(balance);
+          }
+        }
+        const balances = {};
+        for (const [address, balance] of Object.entries(bigIntBalances)) {
+          balances[address] = toSignedBigInt(balance);
+        }
+        result = {
+          schema: BalancesStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: frameSize,
+          balances
+        };
+        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
+      } finally {
+        context.stepSemaphores[step].release();
+      }
+    }
+  }
+  const finalResult = await PayloadBuilder11.addStorageMeta(result);
+  return finalResult;
+}
+__name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
 
-// src/multipliers.ts
-import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL1(1343884111859145740576652n);
-var XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = asAttoXL1(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}`]: [
-    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS,
-    XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS
-  ]
-};
+// src/summary/primitives/balances/balancesSummary.ts
+import { asAddress as asAddress3, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { spanRootAsync } from "@xylabs/telemetry";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockNumber as asXL1BlockNumber2, asXL1BlockRange as asXL1BlockRange2 } 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([
+      rangeStart,
+      headBoundWitness.block
+    ], {
+      name: "balancesSummary"
+    }));
+    const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
+    const balances = {};
+    for (let summary of summaries) {
+      for (const [address, balance] of Object.entries(summary.balances)) {
+        const validAddress = asAddress3(address, () => `Invalid address: ${address}`);
+        balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance);
+      }
+    }
+    return [
+      balances,
+      [
+        rangeStart,
+        headBoundWitness.block
+      ],
+      headHash
+    ];
+  });
+}
+__name(balancesSummary, "balancesSummary");
+
+// src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { isBoundWitness } from "@xyo-network/boundwitness-model";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload2, isHashMeta } from "@xyo-network/payload-model";
+import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
+async function schemasStepSummaryFromRange(context, range) {
+  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
+  const frameSize = range[1] - range[0] + 1;
+  const [headHash] = await context.head();
+  let result = void 0;
+  if (frameSize === 1) {
+    const hash = await hashFromBlockNumber(context, range[0]);
+    const [block, payloads] = await hydrateBlock(context.store, hash);
+    const boundWitnesses = [
+      block,
+      ...payloads.filter((x) => isBoundWitness(x) && isHashMeta(x))
+    ];
+    const schemas = {};
+    for (const bw of boundWitnesses) {
+      schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1;
+      for (const schema of bw.payload_schemas) {
+        schemas[schema] = (schemas[schema] ?? 0) + 1;
+      }
+    }
+    result = {
+      schema: SchemasStepSummarySchema,
+      hash: headHash,
+      stepSize: -1,
+      schemas
+    };
+  } else {
+    const step = StepSizes7.indexOf(frameSize);
+    assertEx11(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes7.join(", ")}`);
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
+    if (isAnyPayload2(summaryResult)) {
+      result = summaryResult;
+    } else {
+      await context.stepSemaphores[step].acquire();
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1);
+        const promises = subRanges.map((subRange) => schemasStepSummaryFromRange(context, subRange));
+        const subResults = await Promise.all(promises);
+        const schemas = {};
+        for (const subResult of subResults) {
+          for (const [schema, count] of Object.entries(subResult.schemas)) {
+            schemas[schema] = (schemas[schema] ?? 0) + count;
+          }
+        }
+        result = {
+          schema: SchemasStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: frameSize,
+          schemas
+        };
+        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
+      } finally {
+        context.stepSemaphores[step].release();
+      }
+    }
+  }
+  return await PayloadBuilder12.addHashMeta(result);
+}
+__name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
+
+// src/summary/primitives/schemas/schemasSummary.ts
+import { isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange3 } 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([
+      rangeStart,
+      headBoundWitness.block
+    ], {
+      name: "schemasSummary"
+    }));
+    const summaries = await Promise.all(ranges.map((range) => schemasStepSummaryFromRange(context, range)));
+    const results = {};
+    for (let summary of summaries) {
+      for (const [schema, count] of Object.entries(summary.schemas)) {
+        results[schema] = (results[schema] ?? 0) + count;
+      }
+    }
+    return [
+      results,
+      [
+        rangeStart,
+        headBoundWitness.block
+      ],
+      headHash
+    ];
+  });
+}
+__name(schemasSummary, "schemasSummary");
+
+// src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
+import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
+
+// src/summary/primitives/transfers/transfersSummary.ts
+import { asAddress as asAddress4, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber4, asXL1BlockRange as asXL1BlockRange4 } 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([
+      rangeStart,
+      headBoundWitness.block
+    ], {
+      name: "transfersSummary"
+    }));
+    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
+    const transfers = {};
+    for (let summary of summaries) {
+      for (const [from, toMap] of Object.entries(summary.transfers)) {
+        const validFrom = asAddress4(from, () => `Invalid address: ${from}`);
+        transfers[validFrom] = transfers[validFrom] ?? {};
+        for (const [to, transfer] of Object.entries(toMap)) {
+          const validTo = asAddress4(to, () => `Invalid address: ${to}`);
+          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer);
+        }
+      }
+    }
+    return [
+      transfers,
+      [
+        rangeStart,
+        headBoundWitness.block
+      ],
+      headHash
+    ];
+  });
+}
+__name(transfersSummary, "transfersSummary");
+function transfersSummaryKey(frameHeadHash, frameSize) {
+  return `${frameHeadHash}|${frameSize}`;
+}
+__name(transfersSummaryKey, "transfersSummaryKey");
 
-// src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts
-import { AsObjectFactory as AsObjectFactory7 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType5, isStorageMeta as isStorageMeta4 } from "@xyo-network/payload-model";
-var ChainIndexingServiceStateSchema = "network.xyo.chain.indexing.service.state";
-var isChainIndexingServiceState = /* @__PURE__ */ __name((payload) => {
-  return isPayloadOfSchemaType5(ChainIndexingServiceStateSchema)(payload);
-}, "isChainIndexingServiceState");
-var asChainIndexingServiceState = AsObjectFactory7.create(isChainIndexingServiceState);
-var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta4(value), "isChainIndexingServiceStateWithStorageMeta");
-var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory7.create(isChainIndexingServiceStateWithStorageMeta);
+// src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
+async function transfersStepSummaryFromRange(context, range) {
+  const frameHeadHash = await hashFromBlockNumber(context, range[1]);
+  const frameSize = range[1] - range[0] + 1;
+  const [headHash] = await context.head();
+  let result = void 0;
+  if (frameSize === 1) {
+    const hash = await hashFromBlockNumber(context, range[0]);
+    const [, payloads] = await hydrateBlock(context.store, hash);
+    const transfers = {};
+    for (const [from, toMap] of Object.entries(netTransfersForPayloads(payloads))) {
+      transfers[from] = transfers[from] ?? {};
+      for (const [to, amount] of Object.entries(toMap)) {
+        transfers[from][to] = toSignedBigInt(amount);
+      }
+    }
+    result = {
+      schema: TransfersStepSummarySchema,
+      hash: headHash,
+      stepSize: -1,
+      transfers
+    };
+  } else {
+    const step = StepSizes8.indexOf(frameSize);
+    assertEx12(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
+    const key = transfersSummaryKey(frameHeadHash, frameSize);
+    const summaryResult = await context.summaryMap.get(key);
+    if (isAnyPayload3(summaryResult)) {
+      result = summaryResult;
+    } else {
+      await context.stepSemaphores[step].acquire();
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1);
+        const promises = subRanges.map((subRange) => transfersStepSummaryFromRange(context, subRange));
+        const subResults = await Promise.all(promises);
+        const bigIntBalances = {};
+        for (const subResult of subResults) {
+          for (const [from, toMap] of Object.entries(subResult.transfers)) {
+            bigIntBalances[from] = bigIntBalances[from] ?? {};
+            for (const [to, transfer] of Object.entries(toMap)) {
+              bigIntBalances[from][to] = (bigIntBalances[from][to] ?? 0n) + parseSignedBigInt(transfer);
+            }
+          }
+        }
+        const transfers = {};
+        for (const [from, toMap] of Object.entries(bigIntBalances)) {
+          transfers[from] = transfers[from] ?? {};
+          for (const [to, transfer] of Object.entries(toMap)) {
+            transfers[from][to] = toSignedBigInt(transfer);
+          }
+        }
+        result = {
+          schema: TransfersStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: frameSize,
+          transfers
+        };
+        await context.summaryMap.set(key, result);
+      } finally {
+        context.stepSemaphores[step].release();
+      }
+    }
+  }
+  const finalResult = await PayloadBuilder13.addStorageMeta(result);
+  return finalResult;
+}
+__name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
 
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
-import { AbstractCreatable, assertEx as assertEx12, exists, isDefined as isDefined11 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
-import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange5, AttoXL1 as AttoXL12, StepSizes as StepSizes9, TransferSchema } from "@xyo-network/xl1-protocol";
 var SimpleAccountBalanceViewer = class extends AbstractCreatable {
   static {
     __name(this, "SimpleAccountBalanceViewer");
@@ -1895,23 +2019,26 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatable {
   get context() {
     return this.params.context;
   }
-  get transferContext() {
-    return this.params.transferContext;
+  get transfersSummaryContext() {
+    return this.params.transfersSummaryContext;
   }
   static async paramsHandler(params) {
-    assertEx12(params.blockViewer, () => "blockViewer is required");
-    assertEx12(params.context, () => "context is required");
-    assertEx12(params.transferContext, () => "transferContext is required");
+    assertEx13(params.blockViewer, () => "blockViewer is required");
+    assertEx13(params.context, () => "context is required");
+    assertEx13(params.transfersSummaryContext, () => "transfersSummaryContext is required");
     return {
       ...await super.paramsHandler(params)
     };
   }
   async accountBalance(address, headOrRange) {
-    const balances = await this.accountsBalances([
+    const balances = await this.accountBalances([
       address
     ], headOrRange);
     return balances[address] ?? AttoXL12(0n);
   }
+  accountBalanceHistories(_addresses, _rangeOrHash) {
+    throw new Error("Method [accountBalanceHistories] not implemented.");
+  }
   async accountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
     const startingRange = asXL1BlockRange5(range ?? [
@@ -1925,7 +2052,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatable {
       const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists);
       const transfers = transferIndexes.map((index) => {
         const hash = block[0].payload_hashes[index];
-        return assertEx12(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+        return assertEx13(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]));
       if (transfers.length === 0) {
         continue;
@@ -1944,20 +2071,53 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatable {
     }
     return result;
   }
-  async accountsBalances(address, _headOrRange) {
-    return await spanRootAsync4("balances", async () => {
-      const summary = await balancesSummary(this.context);
+  async accountBalances(address, _headOrRange) {
+    const [result] = await this.qualifiedAccountBalances(address, _headOrRange);
+    return result;
+  }
+  async qualifiedAccountBalanceHistories(addresses, headOrRange) {
+    const head = asHash5(headOrRange) ?? await this.blockViewer.currentBlockHash();
+    const range = asXL1BlockRange5(headOrRange) ?? asXL1BlockRange5([
+      0,
+      assertEx13(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,
+      await this.qualifiedAccountBalanceHistory(address, range)
+    ]));
+    const entries = qualifiedEntries.map(([address, [history]]) => {
+      return [
+        address,
+        history
+      ];
+    });
+    const qualifiedRange = qualifiedEntries[0][1][1];
+    const qualifiedHeadHash = qualifiedEntries[0][1][2];
+    for (const [_, [__, range2, headHash]] of qualifiedEntries) {
+      assertEx13(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
+      assertEx13(headHash === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
+    }
+    return [
+      Object.fromEntries(entries),
+      qualifiedRange,
+      qualifiedHeadHash
+    ];
+  }
+  async qualifiedAccountBalances(address, _headOrRange) {
+    return await spanRootAsync4("qualifiedAccountsBalances", async () => {
+      const qualifiedSummary = await balancesSummary(this.context);
       const result = {};
       for (const addr of address) {
-        const summaryBalance = summary[addr] ?? 0n;
+        const summaryBalance = qualifiedSummary[0][addr] ?? 0n;
         result[addr] = AttoXL12(summaryBalance < 0n ? 0n : summaryBalance);
       }
-      return result;
+      return [
+        result,
+        qualifiedSummary[1],
+        qualifiedSummary[2]
+      ];
     });
   }
-  accountsBalancesHistory(_addresses, _rangeOrHash) {
-    throw new Error("Method not implemented.");
-  }
   async distillTransferHistory(address, range, max = 50) {
     if (range[1] - range[0] <= StepSizes9[0] || max <= 1) {
       return Array.from({
@@ -1968,7 +2128,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatable {
     const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
       return [
         frame,
-        await transfersStepSummaryFromRange(this.transferContext, frame)
+        await transfersStepSummaryFromRange(this.transfersSummaryContext, frame)
       ];
     }));
     const filteredTransferSummaryPairs = transferSummaryPairs.filter(([_, summary]) => Object.keys(summary.transfers).includes(address));
@@ -1999,23 +2159,263 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatable {
       ...resultBlockNumbers
     ].toSorted((a, b) => b - a).slice(0, max);
   }
+  async qualifiedAccountBalanceHistory(address, headOrRange) {
+    const range = asRange(headOrRange);
+    const headHash = asHash5(headOrRange);
+    const [head] = assertEx13(isDefined11(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+    const startingRange = asXL1BlockRange5(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 result = [];
+    for (const block of blocks) {
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists);
+      const transfers = transferIndexes.map((index) => {
+        const hash = block[0].payload_hashes[index];
+        return assertEx13(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]));
+      if (transfers.length === 0) {
+        continue;
+      }
+      const pairs = transfers.map((transfer) => {
+        return [
+          block[0],
+          transfer
+        ];
+      });
+      result.push(...pairs.map(([block2, transfer]) => [
+        block2,
+        null,
+        transfer
+      ]));
+    }
+    return [
+      result,
+      startingRange,
+      head._hash
+    ];
+  }
+};
+
+// src/simple/block/SimpleBlockViewer.ts
+import { AbstractCreatable as AbstractCreatable2, assertEx as assertEx14, exists as exists2, isDefined as isDefined12, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
+import { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber6 } from "@xyo-network/xl1-protocol";
+
+// src/utils/HydratedCache.ts
+import { LRUCache as LRUCache2 } from "lru-cache";
+var HydratedCache = class {
+  static {
+    __name(this, "HydratedCache");
+  }
+  cache;
+  chainMap;
+  hydrateFunction;
+  constructor(chainMap, hydrateFunction, maxSize = 200) {
+    this.chainMap = chainMap;
+    this.hydrateFunction = hydrateFunction;
+    this.cache = new LRUCache2({
+      max: maxSize
+    });
+  }
+  async get(hash) {
+    const existing = this.cache.get(hash);
+    if (existing !== void 0) return existing;
+    const block = await this.hydrateFunction({
+      chainMap: this.chainMap
+    }, hash) ?? null;
+    if (block !== null) this.cache.set(hash, block);
+    return block;
+  }
+  has(hash) {
+    return this.cache.has(hash);
+  }
+};
+
+// src/utils/isZodError.ts
+import * as z21 from "zod";
+var isZodError = /* @__PURE__ */ __name((error) => {
+  return error instanceof z21.ZodError;
+}, "isZodError");
+var prettifyZodError = /* @__PURE__ */ __name((error) => {
+  return z21.prettifyError(error);
+}, "prettifyZodError");
+
+// src/simple/block/SimpleBlockViewer.ts
+var SimpleBlockViewer = class extends AbstractCreatable2 {
+  static {
+    __name(this, "SimpleBlockViewer");
+  }
+  _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);
+      return asSignedHydratedBlockWithHashMeta(result, true);
+    }, 200);
+    return this._signedHydratedBlockCache;
+  }
+  get payloadCache() {
+    if (this._payloadCache) return this._payloadCache;
+    this._payloadCache = new LruCacheMap({
+      max: 1e4
+    });
+    return this._payloadCache;
+  }
+  static async paramsHandler(params) {
+    assertEx14(params.context, () => "context is required");
+    assertEx14(params.finalizedArchivist, () => "finalizedArchivist is required");
+    return {
+      ...await super.paramsHandler(params)
+    };
+  }
+  async blockByHash(hash) {
+    return await spanRootAsync5("blockByHash", async () => {
+      const cache = this.hydratedBlockCache;
+      return await cache.get(hash);
+    }, this.tracer);
+  }
+  async blockByNumber(blockNumber) {
+    return await spanRootAsync5("blockByNumber", async () => {
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null;
+    }, this.tracer);
+  }
+  async blocksByHash(hash, limit = 50) {
+    return await spanRootAsync5("blocksByHash", async () => {
+      assertEx14(limit > 0, () => "limit must be greater than 0");
+      assertEx14(limit <= 100, () => "limit must be less than 100");
+      const blocks = [];
+      let current = await this.blockByHash(hash);
+      while (current && blocks.length < limit) {
+        blocks.push(current);
+        const previousHash = current[0].previous;
+        if (previousHash === null) break;
+        current = await this.blockByHash(previousHash);
+      }
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
+    }, this.tracer);
+  }
+  async blocksByNumber(blockNumber, limit = 50) {
+    return await spanRootAsync5("blocksByHash", async () => {
+      assertEx14(limit > 0, () => "limit must be greater than 0");
+      assertEx14(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);
+        current = await this.blockByNumber(previousNumber);
+      }
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
+    }, this.tracer);
+  }
+  async currentBlock() {
+    return await spanRootAsync5("currentBlock", async () => {
+      const currentHead = assertEx14(await this.getCurrentHead(), () => "Could not find most recent block");
+      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 assertEx14(block, () => "Could not find current block");
+    }, this.tracer);
+  }
+  async currentBlockHash() {
+    return await spanRootAsync5("currentBlockHash", async () => {
+      const currentHead = assertEx14(await this.getCurrentHead(), () => "Could not find most recent block");
+      return currentHead._hash;
+    }, this.tracer);
+  }
+  async currentBlockNumber() {
+    return await spanRootAsync5("currentBlockNumber", async () => {
+      const currentHead = assertEx14(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);
+  }
+};
+
+// src/simple/blockReward/SimpleBlockRewardViewer.ts
+import { AbstractCreatable as AbstractCreatable3, creatable } from "@xylabs/sdk-js";
+function _ts_decorate(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_decorate, "_ts_decorate");
+var SimpleBlockRewardViewer = class extends AbstractCreatable3 {
+  static {
+    __name(this, "SimpleBlockRewardViewer");
+  }
+  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_decorate([
+  creatable()
+], SimpleBlockRewardViewer);
 
 // src/simple/chainStake/SimpleChainStakeViewer.ts
 import { asAddress as asAddress5, toAddress as toAddress5 } from "@xylabs/sdk-js";
-import { AbstractCreatable as AbstractCreatable3, assertEx as assertEx13, creatable as creatable2 } from "@xylabs/sdk-js";
+import { AbstractCreatable as AbstractCreatable5, assertEx as assertEx15, creatable as creatable3 } from "@xylabs/sdk-js";
 import { Account } from "@xyo-network/account";
 
 // src/simple/chainStakeEvents/SimpleChainStakeEventsViewer.ts
-import { AbstractCreatable as AbstractCreatable2, creatable, isDefined as isDefined12 } from "@xylabs/sdk-js";
-function _ts_decorate(decorators, target, key, desc) {
+import { AbstractCreatable as AbstractCreatable4, creatable as creatable2, isDefined as isDefined13 } from "@xylabs/sdk-js";
+function _ts_decorate2(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_decorate, "_ts_decorate");
-var SimpleChainStakeEventsViewer = class extends AbstractCreatable2 {
+__name(_ts_decorate2, "_ts_decorate");
+var SimpleChainStakeEventsViewer = class extends AbstractCreatable4 {
   static {
     __name(this, "SimpleChainStakeEventsViewer");
   }
@@ -2028,7 +2428,7 @@ var SimpleChainStakeEventsViewer = class extends AbstractCreatable2 {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined12(name)) {
+    if (isDefined13(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -2087,26 +2487,26 @@ var SimpleChainStakeEventsViewer = class extends AbstractCreatable2 {
     return filteredPositions;
   }
 };
-SimpleChainStakeEventsViewer = _ts_decorate([
-  creatable()
+SimpleChainStakeEventsViewer = _ts_decorate2([
+  creatable2()
 ], SimpleChainStakeEventsViewer);
 
 // src/simple/chainStake/SimpleChainStakeViewer.ts
-function _ts_decorate2(decorators, target, key, desc) {
+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_decorate2, "_ts_decorate");
-var SimpleChainStakeViewer = class extends AbstractCreatable3 {
+__name(_ts_decorate3, "_ts_decorate");
+var SimpleChainStakeViewer = class extends AbstractCreatable5 {
   static {
     __name(this, "SimpleChainStakeViewer");
   }
   _chainId;
   _chainStakeEventsViewer;
   get chainId() {
-    return assertEx13(this._chainId, () => "Chain ID not set");
+    return assertEx15(this._chainId, () => "Chain ID not set");
   }
   get chainMap() {
     return this.params.chainMap;
@@ -2118,7 +2518,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable3 {
     return toAddress5(toAddress5(1n));
   }
   get stakeEvents() {
-    return assertEx13(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx15(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
     return toAddress5("0x000000000000000000000000000011");
@@ -2172,7 +2572,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable3 {
     return pending;
   }
   stakeById(id) {
-    return assertEx13(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx15(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];
@@ -2217,8 +2617,8 @@ var SimpleChainStakeViewer = class extends AbstractCreatable3 {
     });
   }
 };
-SimpleChainStakeViewer = _ts_decorate2([
-  creatable2()
+SimpleChainStakeViewer = _ts_decorate3([
+  creatable3()
 ], SimpleChainStakeViewer);
 
 // src/simple/client/SimpleXyoClient.ts
@@ -2339,9 +2739,9 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-import { assertEx as assertEx14, BigIntToJsonZod, isDefined as isDefined13 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
-import { asXL1BlockNumber as asXL1BlockNumber6, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx16, 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";
 var SimpleXyoGatewayRunner = class {
   static {
     __name(this, "SimpleXyoGatewayRunner");
@@ -2360,7 +2760,7 @@ var SimpleXyoGatewayRunner = class {
     return this._connection;
   }
   get dataLakes() {
-    throw new Error("Method not implemented.");
+    throw new Error("Method [dataLakes] not implemented.");
   }
   get signerInstance() {
     return this._signer;
@@ -2370,18 +2770,18 @@ var SimpleXyoGatewayRunner = class {
     return this._dataLakes.length - 1;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx14(this.connectionInstance.viewer, () => "No viewer available on connection");
+    const viewer = assertEx16(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined13(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber6(isDefined13(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber6(isDefined13(exp) ? exp : resolvedNbf + 10, true);
+    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 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 = assertEx14(connection.runner, () => "No runner available on connection");
+    const runner = assertEx16(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
@@ -2393,7 +2793,7 @@ var SimpleXyoGatewayRunner = class {
     ];
   }
   async confirmSubmittedTransaction(txHash, options) {
-    return await confirmSubmittedTransaction(assertEx14(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
+    return await confirmSubmittedTransaction(assertEx16(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
   }
   /** @deprecated use connectionInstance instead */
   connection() {
@@ -2413,7 +2813,7 @@ var SimpleXyoGatewayRunner = class {
       address,
       BigIntToJsonZod.parse(amount)
     ]));
-    const transfer = new PayloadBuilder12({
+    const transfer = new PayloadBuilder14({
       schema: TransferSchema2
     }).fields({
       from,
@@ -2438,6 +2838,112 @@ var SimpleXyoGatewayRunner = class {
   }
 };
 
+// src/simple/mempool/SimpleMempoolRunner.ts
+import { AbstractCreatable as AbstractCreatable6, creatable as creatable4 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/payload-builder";
+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 SimpleMempoolRunner = class extends AbstractCreatable6 {
+  static {
+    __name(this, "SimpleMempoolRunner");
+  }
+  get pendingBlocksArchivist() {
+    return this.params.pendingBlocksArchivist;
+  }
+  get pendingTransactionsArchivist() {
+    return this.params.pendingTransactionsArchivist;
+  }
+  async submitBlocks(blocks) {
+    const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
+      return hydratedBlockToPayloadBundle([
+        await PayloadBuilder15.addHashMeta(bw),
+        await PayloadBuilder15.addHashMeta(payloads)
+      ]);
+    }));
+    const inserted = await this.pendingBlocksArchivist.insert(bundles);
+    return inserted.map((p) => p._hash);
+  }
+  async submitTransactions(transactions) {
+    const bundles = await Promise.all(transactions.map(async ([tx, payloads]) => {
+      return hydratedTransactionToPayloadBundle([
+        await PayloadBuilder15.addHashMeta(tx),
+        await PayloadBuilder15.addHashMeta(payloads)
+      ]);
+    }));
+    const inserted = await this.pendingBlocksArchivist.insert(bundles);
+    return inserted.map((p) => p._hash);
+  }
+};
+SimpleMempoolRunner = _ts_decorate4([
+  creatable4()
+], SimpleMempoolRunner);
+
+// src/simple/mempool/SimpleMempoolViewer.ts
+import { AbstractCreatable as AbstractCreatable7, creatable as creatable5, exists as exists3, isDefined as isDefined15, isHash } from "@xylabs/sdk-js";
+import { isHashMeta as isHashMeta2, isPayloadBundle } from "@xyo-network/payload-model";
+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_decorate5, "_ts_decorate");
+var SimpleMempoolViewer = class extends AbstractCreatable7 {
+  static {
+    __name(this, "SimpleMempoolViewer");
+  }
+  get pendingBlocksArchivist() {
+    return this.params.pendingBlocksArchivist;
+  }
+  get pendingTransactionsArchivist() {
+    return this.params.pendingTransactionsArchivist;
+  }
+  async pendingBlocks({ cursor: providedCursor } = {}) {
+    let cursor = void 0;
+    if (isHash(providedCursor)) {
+      const [p] = await this.pendingBlocksArchivist.get([
+        providedCursor
+      ]);
+      if (isDefined15(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const bundles = await this.pendingBlocksArchivist.next({
+      order: "asc",
+      limit: 100,
+      cursor
+    });
+    const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
+    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists3);
+  }
+  async pendingTransactions({ cursor: providedCursor } = {}) {
+    let cursor = void 0;
+    if (isHash(providedCursor)) {
+      const [p] = await this.pendingTransactionsArchivist.get([
+        providedCursor
+      ]);
+      if (isDefined15(p)) {
+        cursor = p._sequence;
+      }
+    }
+    const bundles = await this.pendingTransactionsArchivist.next({
+      order: "asc",
+      limit: 100,
+      cursor
+    });
+    const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
+    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedTransaction(bundle3)))).filter(exists3);
+  }
+};
+SimpleMempoolViewer = _ts_decorate5([
+  creatable5()
+], SimpleMempoolViewer);
+
 // src/simple/network/SimpleXyoNetwork.ts
 import { isUndefined as isUndefined4 } from "@xylabs/sdk-js";
 import { isNetworkStatus } from "@xyo-network/xl1-protocol";
@@ -2511,7 +3017,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx15 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -2523,7 +3029,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx15(this._store, () => "Store must be defined to get permissions");
+    return assertEx17(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -2581,7 +3087,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { assertEx as assertEx18 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -2592,7 +3098,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx16(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx18(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -2606,7 +3112,7 @@ var MemoryPermissionsStore = class {
 
 // src/simple/runner/SimpleXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/payload-builder";
 var SimpleXyoRunner = class {
   static {
     __name(this, "SimpleXyoRunner");
@@ -2618,7 +3124,7 @@ var SimpleXyoRunner = class {
   async broadcastTransaction(transaction) {
     const archivist = await this.getMempoolArchivist();
     await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder13.hash(transaction[0]);
+    return await PayloadBuilder16.hash(transaction[0]);
   }
   async getMempoolArchivist() {
     if (!this._mempoolArchivist) {
@@ -2631,7 +3137,7 @@ var SimpleXyoRunner = class {
 };
 
 // src/simple/signer/SimpleXyoSigner.ts
-import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/payload-builder";
 import { SignedHydratedTransactionWithHashMetaZod } from "@xyo-network/xl1-protocol";
 var SimpleXyoSigner = class {
   static {
@@ -2652,15 +3158,15 @@ var SimpleXyoSigner = class {
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
     return SignedHydratedTransactionWithHashMetaZod.parse([
-      await PayloadBuilder14.addStorageMeta(txBW),
-      await PayloadBuilder14.addStorageMeta(tx[1])
+      await PayloadBuilder17.addStorageMeta(txBW),
+      await PayloadBuilder17.addStorageMeta(tx[1])
     ]);
   }
 };
 
 // src/simple/timesync/SimpleTimeSyncViewer.ts
-import { asHash as asHash5, assertEx as assertEx17, isDefined as isDefined14 } from "@xylabs/sdk-js";
-import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber7, TimeSchema } from "@xyo-network/xl1-protocol";
+import { asHash as asHash6, assertEx as assertEx19, isDefined as isDefined16 } from "@xylabs/sdk-js";
+import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber8, TimeSchema } from "@xyo-network/xl1-protocol";
 var SimpleTimeSyncViewer = class {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -2674,10 +3180,10 @@ var SimpleTimeSyncViewer = class {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx17(await this.blockViewer.blockByNumber(asXL1BlockNumber7(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx19(await this.blockViewer.blockByNumber(asXL1BlockNumber8(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const timePayload = asTimePayload(isDefined14(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload(isDefined16(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -2740,10 +3246,10 @@ var SimpleTimeSyncViewer = class {
         ];
       }
       case "ethereum": {
-        const provider = assertEx17(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx19(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash5(assertEx17(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash6(assertEx19(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -2755,12 +3261,12 @@ var SimpleTimeSyncViewer = class {
     }
   }
   currentTimePayload() {
-    throw new Error("Method not implemented.");
+    throw new Error("Method [currentTimePayload] not implemented.");
   }
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx18 } from "@xylabs/sdk-js";
+import { assertEx as assertEx20 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload2, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
@@ -2768,38 +3274,34 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const timePayload = asTimePayload2(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
     required: true
   });
-  return assertEx18(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx20(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
-// src/utils/isZodError.ts
-import * as z20 from "zod";
-var isZodError = /* @__PURE__ */ __name((error) => {
-  return error instanceof z20.ZodError;
-}, "isZodError");
-var prettifyZodError = /* @__PURE__ */ __name((error) => {
-  return z20.prettifyError(error);
-}, "prettifyZodError");
-
 // src/viewers/AccountBalance.ts
 import { WithHashMetaZod } from "@xyo-network/payload-model";
 import { TransferZod } from "@xyo-network/xl1-protocol";
 import { BlockBoundWitnessZod, TransactionBoundWitnessZod } from "@xyo-network/xl1-protocol";
-import z21 from "zod";
-var AccountBalanceHistoryItemZod = z21.tuple([
+import z22 from "zod";
+var AccountBalanceHistoryItemZod = z22.tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
   WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
   WithHashMetaZod(TransferZod)
 ]);
 
 // src/viewers/Mempool.ts
-import { HashZod as HashZod2 } from "@xylabs/sdk-js";
-import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
-import z22 from "zod";
-var PendingTransactionsOptionsZod = z22.object({
-  cursor: HashZod2.optional(),
-  limit: z22.number().int().positive().optional(),
-  window: XL1BlockRangeZod.optional()
+import { HashZod as HashZod3 } from "@xylabs/sdk-js";
+import { XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
+import z23 from "zod";
+var PendingTransactionsOptionsZod = z23.object({
+  cursor: HashZod3.optional(),
+  limit: z23.number().int().positive().optional(),
+  window: XL1BlockRangeZod2.optional()
+});
+var PendingBlocksOptionsZod = z23.object({
+  cursor: HashZod3.optional(),
+  limit: z23.number().int().positive().optional(),
+  window: XL1BlockRangeZod2.optional()
 });
 
 // src/viewers/StakeEvents.ts
@@ -2855,18 +3357,25 @@ export {
   GlobalMetaSchema,
   HydratedBlockStateValidationError,
   HydratedBlockValidationError,
+  HydratedCache,
   JSONSchemaMetaSchema,
   LruCacheMap,
   MemoryMap,
   MemoryPermissionsStore,
   MnemonicStringZod,
+  PendingBlocksOptionsZod,
   PendingTransactionsOptionsZod,
+  QualifiedZod,
   RewardMultipliers,
   SchemasStepSummarySchema,
   SimpleAccountBalanceViewer,
+  SimpleBlockRewardViewer,
+  SimpleBlockViewer,
   SimpleChainStakeViewer,
   SimpleDataLakeRunner,
   SimpleDataLakeViewer,
+  SimpleMempoolRunner,
+  SimpleMempoolViewer,
   SimpleTimeSyncViewer,
   SimpleXyoClient,
   SimpleXyoGateway,
@@ -2910,6 +3419,7 @@ export {
   blockPayloadsFromHydratedBlock,
   buildTransaction,
   buildUnsignedTransaction,
+  bundledPayloadToHydratedBlock,
   bundledPayloadToHydratedTransaction,
   calculateFramesFromRange,
   completedStepRewardAddress,
@@ -2922,6 +3432,7 @@ export {
   elevatedPayloads,
   extractElevatedHashes,
   extractElevatedHashesFromScript,
+  findMostRecentBlock,
   flattenHydratedBlock,
   flattenHydratedBlocks,
   flattenHydratedTransaction,
@@ -2934,6 +3445,8 @@ export {
   hydrateBlock,
   hydrateElevatedTransaction,
   hydrateTransaction,
+  hydratedBlockByNumber,
+  hydratedBlockToPayloadBundle,
   hydratedTransactionToPayloadBundle,
   isAddressPairPayload,
   isBalancesStepSummary,
@@ -2963,6 +3476,7 @@ export {
   parseSignedBigInt,
   prettifyZodError,
   readPayloadMapFromStore,
+  rewardFromBlockNumber,
   schemasStepSummaryFromRange,
   schemasSummary,
   signEIP712Message,