@xyo-network/xl1-protocol-sdk 1.16.22 → 1.16.24

package/dist/neutral/index.mjs

@@ -111,10 +111,10 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 // src/block/primitives/blockFromBlockNumber.ts
 import { asHash } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5, StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
 
 // src/model/ChainContext/ChainContext.ts
-import { isDefined as isDefined5, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined7, isUndefined } from "@xylabs/sdk-js";
 
 // src/driver/cache/LruCacheMap.ts
 import { LRUCache } from "lru-cache";
@@ -322,21 +322,41 @@ var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
   });
 }, "netBalancesForPayloads");
 
-// src/payloads/netTransfersForPayloads.ts
-import { hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
+// 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 span2("netTransfersForPayloads", () => {
+  return span3("netTransfersForPayloads", () => {
     const transfers = {};
     for (const payload of payloads) {
-      if (isTransfer2(payload)) {
+      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) + hexToBigInt2(amount);
-          transfers[from][to] = (transfers[from][to] ?? 0n) - hexToBigInt2(amount);
+          transfers[to][from] = (transfers[to][from] ?? 0n) + hexToBigInt3(amount);
+          transfers[from][to] = (transfers[from][to] ?? 0n) - hexToBigInt3(amount);
         }
       }
     }
@@ -356,22 +376,33 @@ var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
 }, "isBalancesStepSummaryWithStorageMeta");
 var asBalancesStepSummaryWithStorageMeta = AsObjectFactory2.create(isBalancesStepSummaryWithStorageMeta);
 
+// 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/payloads/summary/StepSummary.ts
 var StepSummarySchema = "network.xyo.step.summary";
 
 // src/payloads/summary/TransfersSummary.ts
-import { AsObjectFactory as AsObjectFactory3 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType3, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
+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 = isPayloadOfSchemaType3(TransfersStepSummarySchema);
-var asTransfersStepSummary = AsObjectFactory3.create(isTransfersStepSummary);
+var isTransfersStepSummary = isPayloadOfSchemaType4(TransfersStepSummarySchema);
+var asTransfersStepSummary = AsObjectFactory4.create(isTransfersStepSummary);
 var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
-  return isTransfersStepSummary(value) && isStorageMeta2(value);
+  return isTransfersStepSummary(value) && isStorageMeta3(value);
 }, "isTransfersStepSummaryWithStorageMeta");
-var asTransfersStepSummaryWithStorageMeta = AsObjectFactory3.create(isTransfersStepSummaryWithStorageMeta);
+var asTransfersStepSummaryWithStorageMeta = AsObjectFactory4.create(isTransfersStepSummaryWithStorageMeta);
 
 // src/SignedBigInt.ts
-import { hexToBigInt as hexToBigInt3, toHex } from "@xylabs/sdk-js";
+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";
@@ -381,9 +412,9 @@ var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
 }, "isPositiveBigInt");
 var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
-    return -hexToBigInt3(value.negative);
+    return -hexToBigInt4(value.negative);
   } else if (isPositiveBigInt(value)) {
-    return hexToBigInt3(value.positive);
+    return hexToBigInt4(value.positive);
   } else {
     throw new Error("Invalid balance type");
   }
@@ -477,7 +508,7 @@ 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("balanceSummary", async () => {
+  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}`, {
@@ -503,14 +534,232 @@ async function balancesSummary(context) {
 }
 __name(balancesSummary, "balancesSummary");
 
+// src/primitives/summary/schemas/schemasStepSummaryFromRange.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { isBoundWitnessWithStorageMeta } from "@xyo-network/boundwitness-model";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload2 } 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(isBoundWitnessWithStorageMeta)
+    ];
+    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 = 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();
+      }
+    }
+  }
+  const finalResult = await PayloadBuilder2.addStorageMeta(result);
+  return finalResult;
+}
+__name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
+
+// 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}`, {
+      required: true
+    });
+    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;
+  });
+}
+__name(schemasSummary, "schemasSummary");
+
+// 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/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}`, {
+      required: true
+    });
+    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;
+  });
+}
+__name(transfersSummary, "transfersSummary");
+function transfersSummaryKey(frameHeadHash, frameSize) {
+  return `${frameHeadHash}|${frameSize}`;
+}
+__name(transfersSummaryKey, "transfersSummaryKey");
+
+// 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);
+      }
+    }
+    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);
+          }
+        }
+        result = {
+          schema: TransfersStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: frameSize,
+          transfers
+        };
+        await context.summaryMap.set(key, result);
+      } finally {
+        context.stepSemaphores[step].release();
+      }
+    }
+  }
+  const finalResult = await PayloadBuilder3.addStorageMeta(result);
+  return finalResult;
+}
+__name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
+
 // src/primitives/timeBudget.ts
-async function timeBudget(name, logger, func, budget) {
+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 (budget > 0 && duration > budget) {
+  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");
@@ -553,7 +802,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
     max
   }));
   const cacheResult = await cache.get(key);
-  if (isDefined5(cacheResult)) {
+  if (isDefined7(cacheResult)) {
     return cacheResult;
   }
   const result = timeBudgetMs > 0 ? await timeBudget(name, context.logger, func, timeBudgetMs) : await func();
@@ -568,7 +817,7 @@ async function blockFromBlockNumber(context, blockNumber) {
   return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
     const [headHash] = await context.head();
     const result = await context.store.chainMap.get(headHash);
-    let currentBlock = asBlockBoundWitnessWithStorageMeta3(result, () => `Head block not found for hash: ${headHash}`, {
+    let currentBlock = asBlockBoundWitnessWithStorageMeta5(result, () => `Head block not found for hash: ${headHash}`, {
       required: true
     });
     if (currentBlock.block < blockNumber) {
@@ -577,7 +826,7 @@ async function blockFromBlockNumber(context, blockNumber) {
     while (currentBlock.block > blockNumber) {
       let jumpHash = currentBlock.previous;
       let jumpBlockNumber = currentBlock.block - 1;
-      for (const [step, stepSize2] of StepSizes5.entries()) {
+      for (const [step, stepSize2] of StepSizes7.entries()) {
         const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
         if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
           jumpBlockNumber = possibleJumpBlockNumber;
@@ -585,7 +834,7 @@ async function blockFromBlockNumber(context, blockNumber) {
         }
       }
       const newBlock = await context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
-      currentBlock = asBlockBoundWitnessWithStorageMeta3(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+      currentBlock = asBlockBoundWitnessWithStorageMeta5(newBlock, () => `Block not found for hash: ${jumpHash}`, {
         required: true
       });
       if (currentBlock.block === blockNumber) {
@@ -601,7 +850,7 @@ async function blockFromBlockNumber(context, blockNumber) {
 __name(blockFromBlockNumber, "blockFromBlockNumber");
 
 // src/block/primitives/frames/calculateFramesFromRange.ts
-import { asXL1BlockNumber as asXL1BlockNumber2, stepSize } from "@xyo-network/xl1-protocol";
+import { asXL1BlockNumber as asXL1BlockNumber4, stepSize } from "@xyo-network/xl1-protocol";
 function calculateFramesFromRange(range, step) {
   const size = stepSize(step);
   let start = Math.trunc(range[0] / size) * size;
@@ -611,22 +860,22 @@ function calculateFramesFromRange(range, step) {
     start += size;
     remaining.push([
       range[0],
-      asXL1BlockNumber2(Math.min(start - 1, range[1]), true)
+      asXL1BlockNumber4(Math.min(start - 1, range[1]), true)
     ]);
   }
   for (let i = start; i <= range[1]; i += size) {
     if (i + size - 1 <= range[1]) {
       fitted.push([
-        asXL1BlockNumber2(i, {
+        asXL1BlockNumber4(i, {
           name: "calculateFramesFromRange A"
         }),
-        asXL1BlockNumber2(Math.min(i + size - 1, range[1]), {
+        asXL1BlockNumber4(Math.min(i + size - 1, range[1]), {
           name: "calculateFramesFromRange B"
         })
       ]);
     } else {
       remaining.push([
-        asXL1BlockNumber2(i, {
+        asXL1BlockNumber4(i, {
           name: "calculateFramesFromRange C"
         }),
         range[1]
@@ -641,8 +890,8 @@ function calculateFramesFromRange(range, step) {
 __name(calculateFramesFromRange, "calculateFramesFromRange");
 
 // src/block/primitives/frames/deepCalculateFramesFromRange.ts
-import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol";
-function deepCalculateFramesFromRange(range, startingStep = StepSizes6.length - 1) {
+import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
+function deepCalculateFramesFromRange(range, startingStep = StepSizes8.length - 1) {
   const fitted = [];
   let remaining = [
     range
@@ -694,119 +943,6 @@ function toStepIdentityString({ block, step }) {
 }
 __name(toStepIdentityString, "toStepIdentityString");
 
-// src/block/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
-import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
-
-// src/block/primitives/transfers/transfersSummary.ts
-import { asAddress as asAddress2, isDefined as isDefined6 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync2 } from "@xylabs/telemetry";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol";
-async function transfersSummary(transferContext) {
-  return await spanRootAsync2("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}`, {
-      required: true
-    });
-    const rangeStart = asXL1BlockNumber3(isDefined6(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange3([
-      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;
-  });
-}
-__name(transfersSummary, "transfersSummary");
-function transfersSummaryKey(frameHeadHash, frameSize) {
-  return `${frameHeadHash}|${frameSize}`;
-}
-__name(transfersSummaryKey, "transfersSummaryKey");
-
-// src/block/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 = StepSizes7.indexOf(frameSize);
-    assertEx6(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes7.join(", ")}`);
-    const key = transfersSummaryKey(frameHeadHash, frameSize);
-    const summaryResult = await context.summaryMap.get(key);
-    if (isAnyPayload2(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 PayloadBuilder2.addStorageMeta(result);
-  return finalResult;
-}
-__name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
-
 // src/config/Config.ts
 import * as z15 from "zod";
 
@@ -904,34 +1040,22 @@ var ApiConfigZod = z2.object({
   })
 });
 
-// src/config/App.ts
+// src/config/Bridge.ts
 import { globalRegistry as globalRegistry2 } from "zod";
 import * as z3 from "zod";
-var AppConfigZod = z3.object({
-  port: z3.coerce.number().default(3e3).register(globalRegistry2, {
-    default: 3e3,
-    description: "Port for the application",
-    title: "app.port",
-    type: "number"
-  })
-});
-
-// src/config/Bridge.ts
-import { globalRegistry as globalRegistry3 } from "zod";
-import * as z4 from "zod";
-var BridgeConfigZod = z4.object({
-  host: z4.string().default("localhost").register(globalRegistry3, {
+var BridgeConfigZod = z3.object({
+  host: z3.string().default("localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge",
     title: "api.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry3, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry2, {
     description: "Mnemonic for the Bridge wallet",
     title: "api.mnemonic",
     type: "string"
   }),
-  port: z4.coerce.number().default(8081).register(globalRegistry3, {
+  port: z3.coerce.number().default(8081).register(globalRegistry2, {
     default: 8081,
     description: "Port for the Bridge",
     title: "api.port",
@@ -940,40 +1064,46 @@ var BridgeConfigZod = z4.object({
 });
 
 // src/config/Chain.ts
-import { globalRegistry as globalRegistry4 } from "zod";
-import * as z5 from "zod";
-var ChainConfigZod = z5.object({
-  id: z5.string().optional().register(globalRegistry4, {
+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, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
     type: "string"
+  }),
+  genesisRewardAddress: AddressZod.optional().register(globalRegistry3, {
+    description: "Address to send the initial genesis rewards to, if a new chain is being created.",
+    title: "chain.genesisRewardAddress",
+    type: "Address"
   })
 });
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5 } from "zod";
-import * as z6 from "zod";
-var EvmInfuraConfigZod = z6.object({
-  projectId: z6.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry4 } from "zod";
+import * as z5 from "zod";
+var EvmInfuraConfigZod = z5.object({
+  projectId: z5.string().optional().register(globalRegistry4, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z6.string().optional().register(globalRegistry5, {
+  projectSecret: z5.string().optional().register(globalRegistry4, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z6.object({
-  url: z6.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z5.object({
+  url: z5.url().optional().register(globalRegistry4, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z6.object({
-  chainId: z6.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z5.object({
+  chainId: z5.string().optional().register(globalRegistry4, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -984,18 +1114,18 @@ var EvmConfigZod = z6.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6 } from "zod";
-import * as z7 from "zod";
+import { globalRegistry as globalRegistry5 } from "zod";
+import * as z6 from "zod";
 var LogLevels = Object.keys(LogLevel);
-var LogConfigZod = z7.object({
-  logLevel: z7.enum(LogLevels).default("info").register(globalRegistry6, {
+var LogConfigZod = z6.object({
+  logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
     choices: LogLevels,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z7.boolean().default(false).register(globalRegistry6, {
+  silent: z6.boolean().default(false).register(globalRegistry5, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1004,10 +1134,10 @@ var LogConfigZod = z7.object({
 });
 
 // src/config/Mempool.ts
-import { globalRegistry as globalRegistry7 } from "zod";
-import * as z8 from "zod";
-var MempoolConfigZod = z8.object({
-  enabled: z8.string().default("false").transform((val, ctx) => {
+import { globalRegistry as globalRegistry6 } from "zod";
+import * as z7 from "zod";
+var MempoolConfigZod = z7.object({
+  enabled: z7.string().default("false").transform((val, ctx) => {
     const normalized = val.toLowerCase().trim();
     if ([
       "true",
@@ -1026,25 +1156,25 @@ var MempoolConfigZod = z8.object({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z8.NEVER;
-  }).register(globalRegistry7, {
+    return z7.NEVER;
+  }).register(globalRegistry6, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  host: z8.string().default("localhost").register(globalRegistry7, {
+  host: z7.string().default("localhost").register(globalRegistry6, {
     default: "localhost",
     description: "Host for the Mempool",
     title: "mempool.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry6, {
     description: "Mnemonic for the Mempool wallet",
     title: "mempool.mnemonic",
     type: "string"
   }),
-  port: z8.coerce.number().default(8083).register(globalRegistry7, {
+  port: z7.coerce.number().default(8083).register(globalRegistry6, {
     default: 8083,
     description: "Port for the Mempool",
     title: "mempool.port",
@@ -1053,56 +1183,56 @@ var MempoolConfigZod = z8.object({
 });
 
 // src/config/Producer.ts
-import { AddressZod, asAddress as asAddress3 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry8 } from "zod";
-import * as z9 from "zod";
-var ProducerConfigZod = z9.object({
-  allowlist: z9.preprocess((val) => {
+import { AddressZod as AddressZod2, asAddress as asAddress3 } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry7 } from "zod";
+import * as z8 from "zod";
+var ProducerConfigZod = z8.object({
+  allowlist: z8.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress3(s.trim()));
     }
     return val;
-  }, z9.array(AddressZod).optional().register(globalRegistry8, {
+  }, z8.array(AddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  disableIntentRedeclaration: z9.boolean().optional().register(globalRegistry8, {
+  disableIntentRedeclaration: z8.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: z9.coerce.number().optional().register(globalRegistry8, {
+  healthCheckPort: z8.coerce.number().optional().register(globalRegistry7, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
   }),
-  heartbeatInterval: z9.coerce.number().default(36e5).register(globalRegistry8, {
+  heartbeatInterval: z8.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: z9.coerce.number().default(1).register(globalRegistry8, {
+  minStake: z8.coerce.number().default(1).register(globalRegistry7, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
     description: "Mnemonic for the Producer wallet",
     title: "producer.mnemonic",
     type: "string"
   }),
   // TODO: Port schema
-  port: z9.coerce.number().default(8081).register(globalRegistry8, {
+  port: z8.coerce.number().default(8081).register(globalRegistry7, {
     default: 8081,
     description: "Port for the Producer",
     title: "producer.port",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z9.string().optional().register(globalRegistry8, {
+  rewardAddress: z8.string().optional().register(globalRegistry7, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -1110,27 +1240,27 @@ var ProducerConfigZod = z9.object({
 });
 
 // src/config/RewardRedemptionApi.ts
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
-var RewardRedemptionApiConfigZod = z10.object({
-  chainRpcApiUrl: z10.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+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, {
     default: "http://localhost:8080/rpc",
     description: "URL for the Chain RPC API",
     title: "rewardRedemptionApi.chainRpcApiUrl",
     type: "string"
   }),
-  host: z10.string().default("localhost").register(globalRegistry9, {
+  host: z9.string().default("localhost").register(globalRegistry8, {
     default: "localhost",
     description: "Host for the Redemption API",
     title: "rewardRedemptionApi.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry9, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
     description: "Mnemonic for the Redemption API wallet",
     title: "rewardRedemptionApi.mnemonic",
     type: "string"
   }),
-  port: z10.coerce.number().default(8082).register(globalRegistry9, {
+  port: z9.coerce.number().default(8082).register(globalRegistry8, {
     default: 8082,
     description: "Port for the Redemption API",
     title: "rewardRedemptionApi.port",
@@ -1138,13 +1268,24 @@ var RewardRedemptionApiConfigZod = z10.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, {
+    description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
+    title: "services.accountBalanceViewerEndpoint",
+    type: "string"
+  })
+});
+
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined7, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined8, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry10 } from "zod";
 import * as z11 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined2(config)) return false;
-  return isDefined7(config.connectionString) && isDefined7(config.database) && isDefined7(config.domain) && isDefined7(config.password) && isDefined7(config.username);
+  return isDefined8(config.connectionString) && isDefined8(config.database) && isDefined8(config.domain) && isDefined8(config.password) && isDefined8(config.username);
 }, "hasMongoConfig");
 var MongoConfigZod = z11.object({
   // TODO: Create from other arguments
@@ -1190,6 +1331,23 @@ 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, {
+    default: "/metrics",
+    description: "Path for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.path",
+    type: "string"
+  }),
+  port: z13.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({
+  scrape: MetricsScrapeConfigZod
+}).describe("Metrics configuration options");
 var OpenTelemetryConfigZod = z13.object({
   // OpenTelemetry options
   otlpEndpoint: z13.url().optional().register(globalRegistry12, {
@@ -1199,12 +1357,14 @@ var OpenTelemetryConfigZod = z13.object({
   })
 });
 var TelemetryConfigZod = z13.object({
+  // Metrics configuration
+  metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
 // src/config/Validation.ts
-import { AddressZod as AddressZod2, asAddress as asAddress4 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod3, asAddress as asAddress4 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry13 } from "zod";
 import * as z14 from "zod";
 var ValidationConfigZod = z14.object({
@@ -1213,7 +1373,7 @@ var ValidationConfigZod = z14.object({
       return val.split(",").map((s) => asAddress4(s.trim()));
     }
     return val;
-  }, z14.array(AddressZod2).optional().register(globalRegistry13, {
+  }, z14.array(AddressZod3).optional().register(globalRegistry13, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
@@ -1223,7 +1383,7 @@ var ValidationConfigZod = z14.object({
       return val.split(",").map((s) => asAddress4(s.trim()));
     }
     return val;
-  }, z14.array(AddressZod2).optional().register(globalRegistry13, {
+  }, z14.array(AddressZod3).optional().register(globalRegistry13, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
@@ -1237,13 +1397,13 @@ var Xl1CommonConfigSchema = z15.object({
 var ConfigZod = z15.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
-  app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
   bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).describe("Configuration for the Bridge node"),
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
   mempool: MempoolConfigZod.default(MempoolConfigZod.parse({})).describe("Configuration for the mempool"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
   rewardRedemptionApi: RewardRedemptionApiConfigZod.default(RewardRedemptionApiConfigZod.parse({})).describe("Configuration for the rewards redemption API"),
+  services: ServicesConfigZod.default(ServicesConfigZod.parse({})).describe("Configuration for the global services"),
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
   telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
   validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
@@ -1292,7 +1452,7 @@ 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 as AsObjectFactory4 } from "@xylabs/sdk-js";
+import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
 import { isPayloadOfZodType } from "@xyo-network/payload-model";
 import z18 from "zod";
 
@@ -1327,10 +1487,10 @@ var EIP712DataPayloadFieldsZod = z18.object({
 });
 var EIP712DataPayloadSchema = "network.xyo.chains.ethereum.eip712.data";
 var isEIP712DataPayload = isPayloadOfZodType(EIP712DataPayloadFieldsZod, EIP712DataPayloadSchema);
-var asEIP712DataPayload = AsObjectFactory4.create(isEIP712DataPayload);
+var asEIP712DataPayload = AsObjectFactory5.create(isEIP712DataPayload);
 
 // src/eip-712/Payloads/EIP712Signature.ts
-import { AsObjectFactory as AsObjectFactory5, HashZod } from "@xylabs/sdk-js";
+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({
@@ -1340,14 +1500,14 @@ var EIP712SignaturePayloadFieldsZod = z19.object({
 });
 var EIP712SignaturePayloadSchema = "network.xyo.chains.ethereum.eip712.signature";
 var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZod, EIP712SignaturePayloadSchema);
-var asEIP712SignaturePayload = AsObjectFactory5.create(isEIP712SignaturePayload);
+var asEIP712SignaturePayload = AsObjectFactory6.create(isEIP712SignaturePayload);
 
 // src/eip-712/sign.ts
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } 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 PayloadBuilder3.hash(data);
+  const hash = await PayloadBuilder4.hash(data);
   const address = await signer.getAddress();
   return {
     address,
@@ -1359,13 +1519,13 @@ var signEIP712Message = /* @__PURE__ */ __name(async (signer, data) => {
 
 // src/eip-712/verify.ts
 import { asHash as asHash2, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } 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 = asHash2(hash);
-  if (isUndefined3(signedHash) || signedHash !== await PayloadBuilder4.hash(data)) return false;
+  if (isUndefined3(signedHash) || signedHash !== await PayloadBuilder5.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 }, "verifyEIP712Message");
@@ -1383,20 +1543,20 @@ var RewardMultipliers = {
 };
 
 // src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts
-import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
-import { isPayloadOfSchemaType as isPayloadOfSchemaType4, isStorageMeta as isStorageMeta3 } from "@xyo-network/payload-model";
+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 isPayloadOfSchemaType4(ChainIndexingServiceStateSchema)(payload);
+  return isPayloadOfSchemaType5(ChainIndexingServiceStateSchema)(payload);
 }, "isChainIndexingServiceState");
-var asChainIndexingServiceState = AsObjectFactory6.create(isChainIndexingServiceState);
-var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta3(value), "isChainIndexingServiceStateWithStorageMeta");
-var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory6.create(isChainIndexingServiceStateWithStorageMeta);
+var asChainIndexingServiceState = AsObjectFactory7.create(isChainIndexingServiceState);
+var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta4(value), "isChainIndexingServiceStateWithStorageMeta");
+var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory7.create(isChainIndexingServiceStateWithStorageMeta);
 
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
-import { assertEx as assertEx7, exists, isDefined as isDefined8 } from "@xylabs/sdk-js";
-import { spanRootAsync as spanRootAsync3 } from "@xylabs/telemetry";
-import { asRange, asXL1BlockNumber as asXL1BlockNumber4, asXL1BlockRange as asXL1BlockRange4, AttoXL1, StepSizes as StepSizes8, TransferSchema } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx8, exists, isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange5, AttoXL1, StepSizes as StepSizes9, TransferSchema } from "@xyo-network/xl1-protocol";
 var SimpleAccountBalanceViewer = class {
   static {
     __name(this, "SimpleAccountBalanceViewer");
@@ -1410,14 +1570,14 @@ var SimpleAccountBalanceViewer = class {
     this.blockViewer = blockViewer;
   }
   async accountBalance(address, headOrRange) {
-    const balances = await this.accountBalances([
+    const balances = await this.accountsBalances([
       address
     ], headOrRange);
     return balances[address] ?? AttoXL1(0n);
   }
   async accountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
-    const startingRange = asXL1BlockRange4(range ?? [
+    const startingRange = asXL1BlockRange5(range ?? [
       0,
       await this.blockViewer.currentBlockNumber()
     ], true);
@@ -1428,8 +1588,8 @@ var SimpleAccountBalanceViewer = class {
       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 assertEx7(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 || isDefined8(t.transfers[address]));
+        return assertEx8(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 || isDefined9(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -1447,8 +1607,8 @@ var SimpleAccountBalanceViewer = class {
     }
     return result;
   }
-  async accountBalances(address, _headOrRange) {
-    return await spanRootAsync3("balances", async () => {
+  async accountsBalances(address, _headOrRange) {
+    return await spanRootAsync4("balances", async () => {
       const summary = await balancesSummary(this.context);
       const result = {};
       for (const addr of address) {
@@ -1458,16 +1618,16 @@ var SimpleAccountBalanceViewer = class {
       return result;
     });
   }
-  accountBalancesHistories(_addresses, _rangeOrHash) {
+  accountsBalancesHistory(_addresses, _rangeOrHash) {
     throw new Error("Method not implemented.");
   }
   async distillTransferHistory(address, range, max = 50) {
-    if (range[1] - range[0] <= StepSizes8[0] || max <= 1) {
+    if (range[1] - range[0] <= StepSizes9[0] || max <= 1) {
       return Array.from({
         length: range[1] - range[0] + 1
-      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber4(n, true));
+      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber5(n, true));
     }
-    const frames = deepCalculateFramesFromRange(asXL1BlockRange4(range, true));
+    const frames = deepCalculateFramesFromRange(asXL1BlockRange5(range, true));
     const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
       return [
         frame,
@@ -1480,8 +1640,8 @@ var SimpleAccountBalanceViewer = class {
     });
     const resultBlockNumbers = /* @__PURE__ */ new Set();
     for (const [frame] of sortedTransferSummaryPairs) {
-      if (frame[1] - frame[0] + 1 > StepSizes8[0]) {
-        const values = await this.distillTransferHistory(address, asXL1BlockRange4([
+      if (frame[1] - frame[0] + 1 > StepSizes9[0]) {
+        const values = await this.distillTransferHistory(address, asXL1BlockRange5([
           frame[0],
           frame[1] - 1
         ], true), max - resultBlockNumbers.size);
@@ -1505,12 +1665,12 @@ var SimpleAccountBalanceViewer = class {
 };
 
 // src/simple/chainStake/SimpleChainStakeViewer.ts
-import { asAddress as asAddress5, toAddress as toAddress4 } from "@xylabs/sdk-js";
-import { AbstractCreatable as AbstractCreatable2, assertEx as assertEx8, creatable as creatable2 } from "@xylabs/sdk-js";
+import { asAddress as asAddress5, toAddress as toAddress5 } from "@xylabs/sdk-js";
+import { AbstractCreatable as AbstractCreatable2, assertEx as assertEx9, creatable as creatable2 } from "@xylabs/sdk-js";
 import { Account } from "@xyo-network/account";
 
 // src/simple/chainStakeEvents/SimpleChainStakeEventsViewer.ts
-import { AbstractCreatable, creatable, isDefined as isDefined9 } from "@xylabs/sdk-js";
+import { AbstractCreatable, creatable, isDefined as isDefined10 } 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);
@@ -1531,7 +1691,7 @@ var SimpleChainStakeEventsViewer = class extends AbstractCreatable {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined9(name)) {
+    if (isDefined10(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -1609,7 +1769,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable2 {
   _chainId;
   _chainStakeEventsViewer;
   get chainId() {
-    return assertEx8(this._chainId, () => "Chain ID not set");
+    return assertEx9(this._chainId, () => "Chain ID not set");
   }
   get chainMap() {
     return this.params.chainMap;
@@ -1618,13 +1778,13 @@ var SimpleChainStakeViewer = class extends AbstractCreatable2 {
     return this.params.minWithdrawalBlocks ?? 10;
   }
   get rewardsContract() {
-    return toAddress4("0x000000000000000000000000000000");
+    return toAddress5(toAddress5(1n));
   }
   get stakeEvents() {
-    return assertEx8(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx9(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
-    return toAddress4("0x000000000000000000000000000011");
+    return toAddress5("0x000000000000000000000000000011");
   }
   get positions() {
     return this.params.positions;
@@ -1675,7 +1835,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable2 {
     return pending;
   }
   stakeById(id) {
-    return assertEx8(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx9(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];
@@ -1738,7 +1898,7 @@ var SimpleXyoClient = class {
 };
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
-import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
+import { isAnyPayload as isAnyPayload4 } from "@xyo-network/payload-model";
 var SimpleDataLakeViewer = class {
   static {
     __name(this, "SimpleDataLakeViewer");
@@ -1769,13 +1929,13 @@ var SimpleDataLakeViewer = class {
   }
   async has(hash) {
     const value = await this.get(hash);
-    if (isAnyPayload3(value)) {
+    if (isAnyPayload4(value)) {
       return this.isAllowed(value);
     }
     return value !== void 0;
   }
   isAllowed(value) {
-    if (isAnyPayload3(value)) {
+    if (isAnyPayload4(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return true;
@@ -1842,14 +2002,14 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-import { assertEx as assertEx13, BigIntToJsonZod, isDefined as isDefined11 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx14, BigIntToJsonZod, isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 import { TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx9, toHex as toHex2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, toHex as toHex2 } from "@xylabs/sdk-js";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } 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)) {
@@ -1866,14 +2026,14 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder5.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder6.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx9(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx10(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -1887,8 +2047,8 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     signer
   ]).build();
   return [
-    await PayloadBuilder5.addStorageMeta(tx),
-    await PayloadBuilder5.addStorageMeta(txPayloads)
+    await PayloadBuilder6.addStorageMeta(tx),
+    await PayloadBuilder6.addStorageMeta(txPayloads)
   ];
 }
 __name(buildTransaction, "buildTransaction");
@@ -1896,7 +2056,7 @@ __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 { PayloadBuilder as PayloadBuilder7 } 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 = {
@@ -1910,7 +2070,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder6.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder7.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
@@ -1936,7 +2096,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
-import { delay, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { delay, isDefined as isDefined11 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash, options) => {
@@ -1945,7 +2105,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txHash) ?? void 0;
-    if (isDefined10(tx)) {
+    if (isDefined11(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
       return tx;
     } else {
@@ -1962,7 +2122,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } 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) => {
@@ -2021,15 +2181,15 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx10(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx11(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder7.omitStorageMeta(transaction);
+  const cleanTransaction = PayloadBuilder8.omitStorageMeta(transaction);
   const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder7.omitStorageMeta(payloads);
+  const cleanPayloads = PayloadBuilder8.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
 __name(transactionBlockByteCount, "transactionBlockByteCount");
@@ -2087,7 +2247,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { asHash as asHash4 } from "@xylabs/sdk-js";
-import { assertEx as assertEx11, filterAs as filterAs2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12, filterAs as filterAs2 } 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]);
@@ -2096,7 +2256,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs2(hashes, (h) => asHash4(h));
-  assertEx11(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -2110,15 +2270,15 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx11(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
-import { assertEx as assertEx12, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx13, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx12(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx13(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
   signedTx.addresses = [
     account.address
@@ -2126,7 +2286,7 @@ async function signTransaction(tx, account) {
   signedTx.previous_hashes = [
     account.previousHash ?? null
   ];
-  const hash = await PayloadBuilder8.dataHash(signedTx);
+  const hash = await PayloadBuilder9.dataHash(signedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
   signedTx.$signatures = [
@@ -2165,18 +2325,18 @@ var SimpleXyoGatewayRunner = class {
     return this._dataLakes.length - 1;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx13(this.connectionInstance.viewer, () => "No viewer available on connection");
+    const viewer = assertEx14(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined11(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined11(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined11(exp) ? exp : resolvedNbf + 10;
+    const resolvedChainId = isDefined12(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = isDefined12(nbf) ? nbf : await viewer?.currentBlockNumber();
+    const resolvedExp = isDefined12(exp) ? exp : resolvedNbf + 10;
     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 = assertEx13(connection.runner, () => "No runner available on connection");
+    const runner = assertEx14(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
@@ -2188,7 +2348,7 @@ var SimpleXyoGatewayRunner = class {
     ];
   }
   async confirmSubmittedTransaction(txHash, options) {
-    return await confirmSubmittedTransaction(assertEx13(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
+    return await confirmSubmittedTransaction(assertEx14(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
   }
   /** @deprecated use connectionInstance instead */
   connection() {
@@ -2208,7 +2368,7 @@ var SimpleXyoGatewayRunner = class {
       address,
       BigIntToJsonZod.parse(amount)
     ]));
-    const transfer = new PayloadBuilder9({
+    const transfer = new PayloadBuilder10({
       schema: TransferSchema2
     }).fields({
       from,
@@ -2306,7 +2466,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx15 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -2318,7 +2478,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx14(this._store, () => "Store must be defined to get permissions");
+    return assertEx15(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -2376,7 +2536,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx15 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -2387,7 +2547,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx15(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx16(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -2401,7 +2561,7 @@ var MemoryPermissionsStore = class {
 
 // src/simple/runner/SimpleXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
 var SimpleXyoRunner = class {
   static {
     __name(this, "SimpleXyoRunner");
@@ -2413,7 +2573,7 @@ var SimpleXyoRunner = class {
   async broadcastTransaction(transaction) {
     const archivist = await this.getMempoolArchivist();
     await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder10.hash(transaction[0]);
+    return await PayloadBuilder11.hash(transaction[0]);
   }
   async getMempoolArchivist() {
     if (!this._mempoolArchivist) {
@@ -2426,7 +2586,7 @@ var SimpleXyoRunner = class {
 };
 
 // src/simple/signer/SimpleXyoSigner.ts
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
 var SimpleXyoSigner = class {
   static {
     __name(this, "SimpleXyoSigner");
@@ -2446,15 +2606,15 @@ var SimpleXyoSigner = class {
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
     return [
-      await PayloadBuilder11.addStorageMeta(txBW),
-      await PayloadBuilder11.addStorageMeta(tx[1])
+      await PayloadBuilder12.addStorageMeta(txBW),
+      await PayloadBuilder12.addStorageMeta(tx[1])
     ];
   }
 };
 
 // src/simple/timesync/SimpleTimeSyncViewer.ts
-import { asHash as asHash5, assertEx as assertEx16, isDefined as isDefined12 } from "@xylabs/sdk-js";
-import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber5, TimeSchema } from "@xyo-network/xl1-protocol";
+import { asHash as asHash5, assertEx as assertEx17, isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { asTimePayload, asXL1BlockNumber as asXL1BlockNumber6, TimeSchema } from "@xyo-network/xl1-protocol";
 var SimpleTimeSyncViewer = class {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -2468,10 +2628,10 @@ var SimpleTimeSyncViewer = class {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx16(await this.blockViewer.blockByNumber(asXL1BlockNumber5(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx17(await this.blockViewer.blockByNumber(asXL1BlockNumber6(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(isDefined12(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload(isDefined13(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -2534,10 +2694,10 @@ var SimpleTimeSyncViewer = class {
         ];
       }
       case "ethereum": {
-        const provider = assertEx16(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx17(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash5(assertEx16(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash5(assertEx17(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -2554,7 +2714,7 @@ var SimpleTimeSyncViewer = class {
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx17 } from "@xylabs/sdk-js";
+import { assertEx as assertEx18 } 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);
@@ -2562,7 +2722,7 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const timePayload = asTimePayload2(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
     required: true
   });
-  return assertEx17(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx18(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
@@ -2575,6 +2735,337 @@ 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 z35 from "zod";
+
+// src/zod/ArrayBuffer.ts
+import * as z21 from "zod";
+function base64Encode(u8) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return Buffer.from(u8).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < u8.length; i += chunk) {
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+__name(base64Encode, "base64Encode");
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const u8 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
+  return u8;
+}
+__name(base64Decode, "base64Decode");
+var ArrayBufferToJsonZod = z21.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = z21.string().transform((x) => {
+  const u8 = base64Decode(x);
+  return u8.buffer;
+});
+
+// src/zod/BlockBoundWitness.ts
+import { HashZod as HashZod3 } from "@xylabs/sdk-js";
+import { StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
+import { XL1BlockNumberZod } from "@xyo-network/xl1-protocol";
+import * as z24 from "zod";
+
+// src/zod/BoundWitness.ts
+import { AddressZod as AddressZod4, HashZod as HashZod2, HexZod } from "@xylabs/sdk-js";
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
+import { PayloadZod, SchemaZod, StorageMetaZod } from "@xyo-network/payload-model";
+import * as z22 from "zod";
+var BoundWitnessRequiredFieldsZod = z22.object({
+  addresses: z22.array(AddressZod4),
+  payload_hashes: z22.array(HashZod2),
+  payload_schemas: z22.array(SchemaZod),
+  previous_hashes: z22.array(HashZod2.nullable())
+});
+var BoundWitnessMetaZod = z22.object({
+  $destination: AddressZod4.optional(),
+  $sourceQuery: HashZod2.optional(),
+  $signatures: z22.array(z22.union([
+    HexZod,
+    z22.null()
+  ]))
+});
+var BoundWitnessZod = PayloadZod.extend({
+  schema: z22.literal(BoundWitnessSchema)
+}).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, {
+  message: "$signatures length must equal addresses length"
+});
+var AnyBoundWitnessZod = BoundWitnessZod.catchall(z22.any());
+var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
+  message: "all $signatures must be null"
+});
+var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z22.any());
+var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
+var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
+  message: "all $signatures must not be null"
+});
+var SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
+var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z22.any());
+var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z22.any());
+
+// src/zod/Chain.ts
+import { AddressRegEx, toAddress as toAddress6 } from "@xylabs/sdk-js";
+import * as z23 from "zod";
+var ChainZod = z23.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress6(v));
+
+// src/zod/BlockBoundWitness.ts
+var BlockBoundWitnessFieldsZod = z24.object({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod3.nullable(),
+  protocol: z24.number(),
+  step_hashes: z24.array(HashZod3).optional()
+});
+var BlockBoundWitnessMetaZod = z24.object({
+  $epoch: z24.number()
+});
+var BlockBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod2.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
+var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod2.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
+
+// src/zod/HydratedBlock.ts
+import { PayloadZodLoose, WithStorageMetaZod } from "@xyo-network/payload-model";
+import * as z25 from "zod";
+var HydratedBlockZod = z25.tuple([
+  BlockBoundWitnessZod,
+  z25.array(PayloadZodLoose)
+]);
+var HydratedBlockWithStorageMetaZod = z25.tuple([
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  z25.array(WithStorageMetaZod(PayloadZodLoose))
+]);
+var SignedHydratedBlockZod = z25.tuple([
+  SignedBlockBoundWitnessZod,
+  z25.array(PayloadZodLoose)
+]);
+var SignedHydratedBlockToJsonZod = z25.tuple([
+  SignedBlockBoundWitnessZod,
+  z25.array(PayloadZodLoose)
+]);
+var SignedHydratedBlockWithStorageMetaZod = z25.tuple([
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  z25.array(WithStorageMetaZod(PayloadZodLoose))
+]);
+
+// src/zod/HydratedTransaction.ts
+import { asAnyPayload, PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
+import { asSignedHydratedTransaction } from "@xyo-network/xl1-protocol";
+import * as z28 from "zod";
+
+// src/zod/TransactionBoundWitness.ts
+import { StorageMetaZod as StorageMetaZod3 } from "@xyo-network/payload-model";
+import { BlockNumberZod } from "@xyo-network/xl1-protocol";
+import * as z27 from "zod";
+
+// src/zod/TransactionFees.ts
+import { BigIntToJsonZod as BigIntToJsonZod2, HexZod as HexZod2, JsonToBigIntZod } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
+import * as z26 from "zod";
+var AttoZod = z26.bigint();
+var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL12(v));
+var AttoToJsonZod = BigIntToJsonZod2;
+var TransactionFeesHexZod = z26.object({
+  base: HexZod2,
+  gasLimit: HexZod2,
+  gasPrice: HexZod2,
+  priority: HexZod2
+});
+var TransactionFeesBigIntZod = z26.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+var TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform((val) => ({
+  base: JsonToBigIntZod.parse(val.base),
+  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+  priority: JsonToBigIntZod.parse(val.priority)
+}));
+var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) => ({
+  base: BigIntToJsonZod2.parse(val.base),
+  gasLimit: BigIntToJsonZod2.parse(val.gasLimit),
+  gasPrice: BigIntToJsonZod2.parse(val.gasPrice),
+  priority: BigIntToJsonZod2.parse(val.priority)
+}));
+
+// src/zod/TransactionBoundWitness.ts
+var BlockStartZod = z27.object({
+  nbf: BlockNumberZod
+});
+var BlockEndZod = z27.object({
+  exp: BlockNumberZod
+});
+var BlockDurationZod = z27.object({
+  nbf: BlockNumberZod,
+  exp: BlockNumberZod
+});
+var BlockScriptsZod = z27.object({
+  script: z27.array(z27.string()).optional()
+});
+var WithTransactionFeesZod = z27.object({
+  fees: TransactionFeesHexZod
+});
+var TransactionBoundWitnessFields = z27.object({
+  chain: ChainZod,
+  from: ChainZod
+});
+var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod3.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod);
+var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod3.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
+
+// src/zod/HydratedTransaction.ts
+var HydratedTransactionZod = z28.tuple([
+  TransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var UnsignedHydratedTransactionZod = z28.tuple([
+  TransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var SignedHydratedTransactionZod = z28.tuple([
+  SignedTransactionBoundWitnessZod,
+  z28.array(PayloadZodLoose2)
+]);
+var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
+  tx,
+  payloads.map((payload) => payload)
+]));
+var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => [
+  asSignedHydratedTransaction(tx),
+  payloads.map((p) => asAnyPayload(p))
+]);
+
+// src/zod/Permission.ts
+import { z as z29 } from "zod";
+var CaveatTypesZod = z29.enum([
+  "chain",
+  "expiration",
+  "filteredResponse",
+  "rateLimit",
+  "restrictReturnedAccounts"
+]);
+var CaveatsZod = z29.object({
+  type: CaveatTypesZod,
+  value: z29.json()
+});
+var PermissionZod = z29.object({
+  parentCapability: z29.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z29.string()
+});
+var InvokerPermissionZod = PermissionZod.extend({
+  date: z29.number().optional()
+});
+var PermissionRequestZod = z29.record(z29.string(), z29.record(z29.string(), z29.any()));
+var RequestedPermissionZod = z29.object({
+  parentCapability: z29.string(),
+  date: z29.number().optional()
+});
+
+// src/zod/RewardsRangeOptions.ts
+import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
+import { BlockRangeZod, StepIdentityZod } from "@xyo-network/xl1-protocol";
+import { z as z30 } from "zod";
+var RewardsRangeOptionsZod = z30.object({
+  positions: z30.array(z30.number()).optional(),
+  range: BlockRangeZod.optional(),
+  steps: z30.array(StepIdentityZod).optional(),
+  stakers: z30.array(AddressZod5).optional()
+});
+
+// src/zod/Sequence.ts
+import { HexRegExMinMax, toHex as toHex4 } from "@xylabs/sdk-js";
+import { SequenceConstants } from "@xyo-network/payload-model";
+import * as z31 from "zod";
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod = z31.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z31.string().regex(LocalSequenceRegex).transform((v) => toHex4(v));
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod = z31.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z31.string().regex(QualifiedSequenceRegex).transform((v) => toHex4(v));
+var SequenceToStringZod = z31.union([
+  LocalSequenceToStringZod,
+  QualifiedSequenceToStringZod
+]);
+var SequenceFromStringZod = z31.union([
+  LocalSequenceFromStringZod,
+  QualifiedSequenceFromStringZod
+]);
+
+// src/zod/Stake.ts
+import { AddressZod as AddressZod6, HexZod as HexZod3 } from "@xylabs/sdk-js";
+import * as z32 from "zod";
+var StakeZod = z32.object({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: z32.number(),
+  // the unique id for the stake item
+  id: z32.number(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: z32.number(),
+  // the address that is being staked
+  staked: AddressZod6,
+  // the address that owns the stake
+  staker: AddressZod6,
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: z32.number()
+});
+var StakeToJsonZod = StakeZod.transform((val) => ({
+  addBlock: val.addBlock,
+  amount: AttoToJsonZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: AddressZod6.parse(val.staked),
+  staker: AddressZod6.parse(val.staker),
+  withdrawBlock: val.withdrawBlock
+}));
+var JsonToStakeZod = StakeZod.extend({
+  amount: HexZod3
+}).transform((val) => ({
+  addBlock: val.addBlock,
+  amount: JsonToAttoZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: val.staked,
+  staker: val.staker,
+  withdrawBlock: val.withdrawBlock
+}));
+
+// src/zod/TimeDomain.ts
+import * as z33 from "zod";
+var TimeDomainZod = z33.union([
+  z33.literal("xl1"),
+  z33.literal("epoch"),
+  z33.literal("ethereum")
+]);
+
+// src/zod/TransferPair.ts
+import { AddressZod as AddressZod7 } from "@xylabs/sdk-js";
+import z34 from "zod";
+var TransferPairZod = z34.tuple([
+  AddressZod7,
+  AddressZod7
+]);
+
+// src/viewers/AccountBalance.ts
+var AccountBalanceHistoryItemZod = z35.tuple([
+  WithHashMetaZod(BlockBoundWitnessZod),
+  WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
+  WithHashMetaZod(TransferZod)
+]);
+
 // src/viewers/StakeEvents.ts
 var StakeEventNames = [
   "StakeAdded",
@@ -2612,12 +3103,29 @@ var generateXyoBaseWalletFromPhrase = /* @__PURE__ */ __name((walletPhrase) => {
 export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
+  AccountBalanceHistoryItemZod,
   AddressPairSchema,
+  AnyBoundWitnessZod,
+  AnySignedBoundWitnessWithStorageMetaZod,
+  AnySignedBoundWitnessZod,
+  AnyUnsignedBoundWitnessZod,
+  ArrayBufferToJsonZod,
+  AttoToJsonZod,
+  AttoZod,
   BalancesStepSummarySchema,
+  BlockBoundWitnessZod,
+  BlockDurationZod,
+  BlockEndZod,
+  BlockScriptsZod,
+  BlockStartZod,
   BlockValidationError,
+  BoundWitnessZod,
   CHANGE_ADDRESS,
   COIN_TYPES,
+  CaveatTypesZod,
+  CaveatsZod,
   ChainIndexingServiceStateSchema,
+  ChainZod,
   ConfigZod,
   DEFAULT_WALLET_PATH,
   EIP712DataPayloadFieldsZod,
@@ -2627,12 +3135,40 @@ export {
   GlobalMetaSchema,
   HydratedBlockStateValidationError,
   HydratedBlockValidationError,
+  HydratedBlockWithStorageMetaZod,
+  HydratedBlockZod,
+  HydratedTransactionZod,
+  InvokerPermissionZod,
   JSONSchemaMetaSchema,
+  JsonToArrayBufferZod,
+  JsonToAttoZod,
+  JsonToSignedHydratedTransactionZod,
+  JsonToStakeZod,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
   LruCacheMap,
   MemoryMap,
   MemoryPermissionsStore,
   MnemonicStringZod,
+  PermissionRequestZod,
+  PermissionZod,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
+  RequestedPermissionZod,
   RewardMultipliers,
+  RewardsRangeOptionsZod,
+  SchemasStepSummarySchema,
+  SequenceFromStringZod,
+  SequenceToStringZod,
+  SignedBlockBoundWitnessZod,
+  SignedBoundWitnessWithStorageMetaZod,
+  SignedBoundWitnessZod,
+  SignedHydratedBlockToJsonZod,
+  SignedHydratedBlockWithStorageMetaZod,
+  SignedHydratedBlockZod,
+  SignedHydratedTransactionToJsonZod,
+  SignedHydratedTransactionZod,
+  SignedTransactionBoundWitnessZod,
   SimpleAccountBalanceViewer,
   SimpleChainStakeViewer,
   SimpleDataLakeRunner,
@@ -2646,15 +3182,28 @@ export {
   SimpleXyoRunner,
   SimpleXyoSigner,
   StakeEventNames,
+  StakeToJsonZod,
+  StakeZod,
   StepSummarySchema,
   TODO,
+  TimeDomainZod,
+  TransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesBigIntZod,
+  TransactionFeesHexZod,
+  TransactionFeesJsonToBigIntZod,
+  TransferPairZod,
   TransfersStepSummarySchema,
   TypedDataDomainZod,
   TypedDataFieldZod,
   TypedDataTypesZod,
   TypedDataValueZod,
+  UnsignedBoundWitnessWithStorageMetaZod,
+  UnsignedBoundWitnessZod,
+  UnsignedHydratedTransactionZod,
   UsageMetaSchema,
   WALLET_COMPLIANCE,
+  WithTransactionFeesZod,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_END_EPOCH,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK,
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS,
@@ -2670,6 +3219,8 @@ export {
   asEIP712DataPayload,
   asEIP712SignaturePayload,
   asOptionalAddressPairPayload,
+  asSchemasStepSummary,
+  asSchemasStepSummaryWithStorageMeta,
   asTransfersStepSummary,
   asTransfersStepSummaryWithStorageMeta,
   balancesStepSummaryFromRange,
@@ -2716,16 +3267,21 @@ export {
   isPositiveBigInt,
   isReadArchivist,
   isReadWriteArchivist,
+  isSchemasStepSummary,
+  isSchemasStepSummaryWithStorageMeta,
   isTransfersStepSummary,
   isTransfersStepSummaryWithStorageMeta,
   isUsageMeta,
   isWriteArchivist,
   isZodError,
   netBalancesForPayloads,
+  netSchemasForPayloads,
   netTransfersForPayloads,
   parseSignedBigInt,
   prettifyZodError,
   readPayloadMapFromStore,
+  schemasStepSummaryFromRange,
+  schemasSummary,
   signEIP712Message,
   signTransaction,
   stepBlockRange,