@xyo-network/xl1-protocol-sdk 1.16.23 → 1.16.25

package/dist/neutral/index.mjs

@@ -10,9 +10,9 @@ __name(allHashesPresent, "allHashesPresent");
 
 // src/block/hydrate/blockPayloadsFromHydratedBlock.ts
 import { assertEx } from "@xylabs/sdk-js";
-import { isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { isTransactionBoundWitness } from "@xyo-network/xl1-protocol";
 var blockPayloadsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
-  return block[0].payload_hashes.map((hash) => assertEx(block[1].find((p) => p._hash === hash), () => `missing payload ${hash}`)).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
+  return block[0].payload_hashes.map((hash) => assertEx(block[1].find((p) => p._hash === hash), () => `missing payload ${hash}`)).filter((x) => !isTransactionBoundWitness(x));
 }, "blockPayloadsFromHydratedBlock");
 
 // src/block/hydrate/flattenHydratedBlock.ts
@@ -29,7 +29,7 @@ var flattenHydratedBlocks = /* @__PURE__ */ __name((hydratedBlocks) => hydratedB
 
 // src/block/hydrate/hydrateBlock.ts
 import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var hydrateBlock = /* @__PURE__ */ __name(async ({ chainMap }, hash, maxDepth = 1, minDepth = maxDepth) => {
   assertEx2(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
   assertEx2(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
@@ -45,7 +45,7 @@ var hydrateBlock = /* @__PURE__ */ __name(async ({ chainMap }, hash, maxDepth =
     bw,
     blkPayloads
   ];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta2);
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await chainMap.getMany(transactionsPayloadHashes);
   assertEx2(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
@@ -67,10 +67,9 @@ var hydrateBlock = /* @__PURE__ */ __name(async ({ chainMap }, hash, maxDepth =
 }, "hydrateBlock");
 
 // src/block/hydrate/transactionsFromHydratedBlock.ts
-import { filterAs } from "@xylabs/sdk-js";
-import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
 var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
-  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
+  return block[1].filter(isTransactionBoundWitnessWithStorageMeta2);
 }, "transactionsFromHydratedBlock");
 
 // src/block/hydrate/tryHydrateBlock.ts
@@ -109,9 +108,9 @@ var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth =
 }, "tryHydrateBlock");
 
 // src/block/primitives/blockFromBlockNumber.ts
-import { asHash } from "@xylabs/sdk-js";
+import { asHash as asHash3, isDefined as isDefined9 } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5, StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
+import { asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol";
 
 // src/model/ChainContext/ChainContext.ts
 import { isDefined as isDefined7, isUndefined } from "@xylabs/sdk-js";
@@ -511,9 +510,7 @@ 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}`, {
-      required: true
-    });
+    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,
@@ -536,9 +533,9 @@ __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 { isBoundWitness } from "@xyo-network/boundwitness-model";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
+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]);
@@ -550,7 +547,7 @@ async function schemasStepSummaryFromRange(context, range) {
     const [block, payloads] = await hydrateBlock(context.store, hash);
     const boundWitnesses = [
       block,
-      ...payloads.filter(isBoundWitnessWithStorageMeta)
+      ...payloads.filter((x) => isBoundWitness(x) && isHashMeta(x))
     ];
     const schemas = {};
     for (const bw of boundWitnesses) {
@@ -595,8 +592,7 @@ async function schemasStepSummaryFromRange(context, range) {
       }
     }
   }
-  const finalResult = await PayloadBuilder2.addStorageMeta(result);
-  return finalResult;
+  return await PayloadBuilder2.addHashMeta(result);
 }
 __name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
 
@@ -608,9 +604,7 @@ 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 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,
@@ -644,9 +638,7 @@ 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 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,
@@ -811,114 +803,445 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
 }
 __name(withContextCacheResponse, "withContextCacheResponse");
 
-// 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);
-    let currentBlock = asBlockBoundWitnessWithStorageMeta5(result, () => `Head block not found for hash: ${headHash}`, {
-      required: true
-    });
-    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 = asHash(currentBlock.step_hashes.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
-        }
-      }
-      const newBlock = await context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
-      currentBlock = asBlockBoundWitnessWithStorageMeta5(newBlock, () => `Block not found for hash: ${jumpHash}`, {
-        required: true
-      });
-      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/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/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)
-    ]);
+// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBundleSchema } from "@xyo-network/payload-model";
+
+// 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");
   }
-  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]
-      ]);
-    }
+  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 fields = {
+    ...txBoundWitnessFields,
+    from: from ?? (Array.isArray(signer) ? assertEx8(signer.at(0)?.address) : signer.address)
+  };
+  if (script.length > 0) {
+    fields.script = script;
   }
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).signers(Array.isArray(signer) ? signer : [
+    signer
+  ]).build();
   return [
-    fitted,
-    remaining
+    await PayloadBuilder5.addHashMeta(tx),
+    await PayloadBuilder5.addHashMeta(txPayloads)
   ];
 }
-__name(calculateFramesFromRange, "calculateFramesFromRange");
+__name(buildTransaction, "buildTransaction");
 
-// 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
+// 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}`);
+  }
+  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
   ];
-  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);
+}
+__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);
+      }
     }
-    remaining = newRemaining;
   }
-  for (const range2 of remaining) {
-    for (let i = range2[0]; i <= range2[1]; i++) {
-      fitted.push([
-        i,
-        i
-      ]);
+}, "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);
+      }
     }
   }
-  return fitted.toSorted((a, b) => a[0] - b[0]);
-}
-__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
+  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/block/primitives/hashFromBlockNumber.ts
-async function hashFromBlockNumber(context, blockNumber) {
+// 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");
@@ -1040,34 +1363,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",
@@ -1077,15 +1388,15 @@ var BridgeConfigZod = z4.object({
 
 // src/config/Chain.ts
 import { AddressZod } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry4 } from "zod";
-import * as z5 from "zod";
-var ChainConfigZod = z5.object({
-  id: z5.string().optional().register(globalRegistry4, {
+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(globalRegistry4, {
+  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"
@@ -1093,29 +1404,29 @@ var ChainConfigZod = z5.object({
 });
 
 // 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"
@@ -1126,18 +1437,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",
@@ -1146,10 +1457,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",
@@ -1168,25 +1479,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",
@@ -1196,60 +1507,55 @@ var MempoolConfigZod = z8.object({
 
 // src/config/Producer.ts
 import { AddressZod as AddressZod2, 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 { 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(AddressZod2).optional().register(globalRegistry8, {
+  }, z8.array(AddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  apiEndpoint: z9.string().optional().register(globalRegistry8, {
-    description: "Endpoint of the API to use for chain data",
-    title: "producer.apiEndpoint",
-    type: "string"
-  }),
-  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"
@@ -1257,27 +1563,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",
@@ -1285,13 +1591,29 @@ 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"
+  }),
+  apiEndpoint: z10.string().optional().register(globalRegistry9, {
+    description: "Endpoint of the API to use for instantiating an external Viewers",
+    title: "services.apiEndpoint",
+    type: "string"
+  })
+});
+
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined8, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined10, 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 isDefined8(config.connectionString) && isDefined8(config.database) && isDefined8(config.domain) && isDefined8(config.password) && isDefined8(config.username);
+  return isDefined10(config.connectionString) && isDefined10(config.database) && isDefined10(config.domain) && isDefined10(config.password) && isDefined10(config.username);
 }, "hasMongoConfig");
 var MongoConfigZod = z11.object({
   // TODO: Create from other arguments
@@ -1337,6 +1659,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, {
@@ -1346,6 +1685,8 @@ 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");
@@ -1384,13 +1725,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")
@@ -1490,11 +1831,11 @@ var isEIP712SignaturePayload = isPayloadOfZodType2(EIP712SignaturePayloadFieldsZ
 var asEIP712SignaturePayload = AsObjectFactory6.create(isEIP712SignaturePayload);
 
 // src/eip-712/sign.ts
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+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 PayloadBuilder4.hash(data);
+  const hash = await PayloadBuilder10.hash(data);
   const address = await signer.getAddress();
   return {
     address,
@@ -1505,14 +1846,14 @@ var signEIP712Message = /* @__PURE__ */ __name(async (signer, data) => {
 }, "signEIP712Message");
 
 // src/eip-712/verify.ts
-import { asHash as asHash2, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { asHash as asHash4, isUndefined as isUndefined3 } 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 = asHash2(hash);
-  if (isUndefined3(signedHash) || signedHash !== await PayloadBuilder5.hash(data)) return false;
+  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");
@@ -1541,26 +1882,35 @@ var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value)
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory7.create(isChainIndexingServiceStateWithStorageMeta);
 
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
-import { assertEx as assertEx8, exists, isDefined as isDefined9 } from "@xylabs/sdk-js";
+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, StepSizes as StepSizes9, TransferSchema } from "@xyo-network/xl1-protocol";
-var SimpleAccountBalanceViewer = class {
+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");
   }
-  blockViewer;
-  context;
-  transferContext;
-  constructor(context, transferContext, blockViewer) {
-    this.context = context;
-    this.transferContext = transferContext;
-    this.blockViewer = blockViewer;
+  get blockViewer() {
+    return this.params.blockViewer;
   }
-  async accountBalance(address, headOrRange) {
-    const balances = await this.accountsBalances([
-      address
-    ], headOrRange);
-    return balances[address] ?? AttoXL1(0n);
+  get context() {
+    return this.params.context;
+  }
+  get transferContext() {
+    return this.params.transferContext;
+  }
+  static async paramsHandler(params) {
+    assertEx12(params.blockViewer, () => "blockViewer is required");
+    assertEx12(params.context, () => "context is required");
+    assertEx12(params.transferContext, () => "transferContext is required");
+    return {
+      ...await super.paramsHandler(params)
+    };
+  }
+  async accountBalance(address, headOrRange) {
+    const balances = await this.accountsBalances([
+      address
+    ], headOrRange);
+    return balances[address] ?? AttoXL12(0n);
   }
   async accountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
@@ -1575,8 +1925,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 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]));
+        return assertEx12(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;
       }
@@ -1600,7 +1950,7 @@ var SimpleAccountBalanceViewer = class {
       const result = {};
       for (const addr of address) {
         const summaryBalance = summary[addr] ?? 0n;
-        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance);
+        result[addr] = AttoXL12(summaryBalance < 0n ? 0n : summaryBalance);
       }
       return result;
     });
@@ -1653,11 +2003,11 @@ var SimpleAccountBalanceViewer = class {
 
 // src/simple/chainStake/SimpleChainStakeViewer.ts
 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 { AbstractCreatable as AbstractCreatable3, assertEx as assertEx13, creatable as creatable2 } from "@xylabs/sdk-js";
 import { Account } from "@xyo-network/account";
 
 // src/simple/chainStakeEvents/SimpleChainStakeEventsViewer.ts
-import { AbstractCreatable, creatable, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { AbstractCreatable as AbstractCreatable2, creatable, isDefined as isDefined12 } 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);
@@ -1665,7 +2015,7 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-var SimpleChainStakeEventsViewer = class extends AbstractCreatable {
+var SimpleChainStakeEventsViewer = class extends AbstractCreatable2 {
   static {
     __name(this, "SimpleChainStakeEventsViewer");
   }
@@ -1678,7 +2028,7 @@ var SimpleChainStakeEventsViewer = class extends AbstractCreatable {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined10(name)) {
+    if (isDefined12(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -1749,14 +2099,14 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var SimpleChainStakeViewer = class extends AbstractCreatable2 {
+var SimpleChainStakeViewer = class extends AbstractCreatable3 {
   static {
     __name(this, "SimpleChainStakeViewer");
   }
   _chainId;
   _chainStakeEventsViewer;
   get chainId() {
-    return assertEx9(this._chainId, () => "Chain ID not set");
+    return assertEx13(this._chainId, () => "Chain ID not set");
   }
   get chainMap() {
     return this.params.chainMap;
@@ -1768,7 +2118,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable2 {
     return toAddress5(toAddress5(1n));
   }
   get stakeEvents() {
-    return assertEx9(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx13(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
     return toAddress5("0x000000000000000000000000000011");
@@ -1822,7 +2172,7 @@ var SimpleChainStakeViewer = class extends AbstractCreatable2 {
     return pending;
   }
   stakeById(id) {
-    return assertEx9(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx13(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];
@@ -1989,301 +2339,9 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-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 assertEx10, toHex as toHex2 } from "@xylabs/sdk-js";
-import { BoundWitnessBuilder } from "@xyo-network/boundwitness-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)) {
-    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 PayloadBuilder6.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
-  const fields = {
-    ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx10(signer.at(0)?.address) : signer.address)
-  };
-  if (script.length > 0) {
-    fields.script = script;
-  }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
-    $signatures: []
-  }).payloads([
-    ...onChainPayloads,
-    ...offChainPayloads
-  ]).signers(Array.isArray(signer) ? signer : [
-    signer
-  ]).build();
-  return [
-    await PayloadBuilder6.addStorageMeta(tx),
-    await PayloadBuilder6.addStorageMeta(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 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 = {
-    chain,
-    fees: {
-      base: toHex3(fees.base),
-      gasLimit: toHex3(fees.gasLimit),
-      gasPrice: toHex3(fees.gasPrice),
-      priority: toHex3(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder7.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
-  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();
-  return [
-    tx,
-    txPayloads
-  ];
-}
-__name(buildUnsignedTransaction, "buildUnsignedTransaction");
-
-// src/transaction/confirmSubmittedTransaction.ts
-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) => {
-  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 (isDefined11(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 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) => {
-  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 assertEx11(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
-}, "hydrateElevatedTransaction");
-
-// src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
-function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder8.omitStorageMeta(transaction);
-  const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder8.omitStorageMeta(payloads);
-  return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
-}
-__name(transactionBlockByteCount, "transactionBlockByteCount");
-
-// src/transaction/primitives/transactionElevatedPayloads.ts
-import { asHash as asHash3 } 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) => asHash3(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 as AttoXL12, TransactionGasCosts } from "@xyo-network/xl1-protocol";
-function transactionBytesRequiredGas([transaction, payloads]) {
-  const transactionBlockBytes = transactionBlockByteCount([
-    transaction,
-    payloads
-  ]);
-  return AttoXL12(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 AttoXL12(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 asHash4 } 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]);
-  return filterAs2(hashes, (h) => asHash4(h));
-}, "tryExtractElevatedHashesFromScript");
-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));
-  assertEx12(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);
-  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
-  return filtered;
-}, "extractElevatedHashes");
-
-// src/transaction/signTransaction.ts
-import { assertEx as assertEx13, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
-async function signTransaction(tx, account) {
-  assertEx13(tx.from === account.address, () => "Signer address does not match transaction from address");
-  const signedTx = structuredClone(tx);
-  signedTx.addresses = [
-    account.address
-  ];
-  signedTx.previous_hashes = [
-    account.previousHash ?? null
-  ];
-  const hash = await PayloadBuilder9.dataHash(signedTx);
-  const hashBytes = toArrayBuffer(hash);
-  const [signature] = await account.sign(hashBytes);
-  signedTx.$signatures = [
-    hexFromArrayBuffer(signature)
-  ];
-  return signedTx;
-}
-__name(signTransaction, "signTransaction");
-
-// 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";
 var SimpleXyoGatewayRunner = class {
   static {
     __name(this, "SimpleXyoGatewayRunner");
@@ -2314,9 +2372,9 @@ var SimpleXyoGatewayRunner = class {
   async addPayloadsToChain(onChain, offChain, options) {
     const viewer = assertEx14(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined12(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined12(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined12(exp) ? exp : resolvedNbf + 10;
+    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 tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await (await this.signer()).address(), fees);
     return await this.addTransactionToChain(tx);
   }
@@ -2355,7 +2413,7 @@ var SimpleXyoGatewayRunner = class {
       address,
       BigIntToJsonZod.parse(amount)
     ]));
-    const transfer = new PayloadBuilder10({
+    const transfer = new PayloadBuilder12({
       schema: TransferSchema2
     }).fields({
       from,
@@ -2548,7 +2606,7 @@ var MemoryPermissionsStore = class {
 
 // src/simple/runner/SimpleXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
 var SimpleXyoRunner = class {
   static {
     __name(this, "SimpleXyoRunner");
@@ -2560,7 +2618,7 @@ var SimpleXyoRunner = class {
   async broadcastTransaction(transaction) {
     const archivist = await this.getMempoolArchivist();
     await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder11.hash(transaction[0]);
+    return await PayloadBuilder13.hash(transaction[0]);
   }
   async getMempoolArchivist() {
     if (!this._mempoolArchivist) {
@@ -2573,7 +2631,8 @@ var SimpleXyoRunner = class {
 };
 
 // src/simple/signer/SimpleXyoSigner.ts
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/payload-builder";
+import { SignedHydratedTransactionWithHashMetaZod } from "@xyo-network/xl1-protocol";
 var SimpleXyoSigner = class {
   static {
     __name(this, "SimpleXyoSigner");
@@ -2592,16 +2651,16 @@ var SimpleXyoSigner = class {
   }
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
-    return [
-      await PayloadBuilder12.addStorageMeta(txBW),
-      await PayloadBuilder12.addStorageMeta(tx[1])
-    ];
+    return SignedHydratedTransactionWithHashMetaZod.parse([
+      await PayloadBuilder14.addStorageMeta(txBW),
+      await PayloadBuilder14.addStorageMeta(tx[1])
+    ]);
   }
 };
 
 // src/simple/timesync/SimpleTimeSyncViewer.ts
-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";
+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";
 var SimpleTimeSyncViewer = class {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -2615,10 +2674,10 @@ var SimpleTimeSyncViewer = class {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx17(await this.blockViewer.blockByNumber(asXL1BlockNumber6(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx17(await this.blockViewer.blockByNumber(asXL1BlockNumber7(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(isDefined13(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload(isDefined14(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -2725,334 +2784,24 @@ var prettifyZodError = /* @__PURE__ */ __name((error) => {
 // 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([
+import { BlockBoundWitnessZod, TransactionBoundWitnessZod } from "@xyo-network/xl1-protocol";
+import z21 from "zod";
+var AccountBalanceHistoryItemZod = z21.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()
+});
+
 // src/viewers/StakeEvents.ts
 var StakeEventNames = [
   "StakeAdded",
@@ -3092,27 +2841,11 @@ export {
   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,
@@ -3122,40 +2855,14 @@ export {
   GlobalMetaSchema,
   HydratedBlockStateValidationError,
   HydratedBlockValidationError,
-  HydratedBlockWithStorageMetaZod,
-  HydratedBlockZod,
-  HydratedTransactionZod,
-  InvokerPermissionZod,
   JSONSchemaMetaSchema,
-  JsonToArrayBufferZod,
-  JsonToAttoZod,
-  JsonToSignedHydratedTransactionZod,
-  JsonToStakeZod,
-  LocalSequenceFromStringZod,
-  LocalSequenceToStringZod,
   LruCacheMap,
   MemoryMap,
   MemoryPermissionsStore,
   MnemonicStringZod,
-  PermissionRequestZod,
-  PermissionZod,
-  QualifiedSequenceFromStringZod,
-  QualifiedSequenceToStringZod,
-  RequestedPermissionZod,
+  PendingTransactionsOptionsZod,
   RewardMultipliers,
-  RewardsRangeOptionsZod,
   SchemasStepSummarySchema,
-  SequenceFromStringZod,
-  SequenceToStringZod,
-  SignedBlockBoundWitnessZod,
-  SignedBoundWitnessWithStorageMetaZod,
-  SignedBoundWitnessZod,
-  SignedHydratedBlockToJsonZod,
-  SignedHydratedBlockWithStorageMetaZod,
-  SignedHydratedBlockZod,
-  SignedHydratedTransactionToJsonZod,
-  SignedHydratedTransactionZod,
-  SignedTransactionBoundWitnessZod,
   SimpleAccountBalanceViewer,
   SimpleChainStakeViewer,
   SimpleDataLakeRunner,
@@ -3169,28 +2876,15 @@ 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,
@@ -3216,6 +2910,7 @@ export {
   blockPayloadsFromHydratedBlock,
   buildTransaction,
   buildUnsignedTransaction,
+  bundledPayloadToHydratedTransaction,
   calculateFramesFromRange,
   completedStepRewardAddress,
   confirmSubmittedTransaction,
@@ -3239,6 +2934,7 @@ export {
   hydrateBlock,
   hydrateElevatedTransaction,
   hydrateTransaction,
+  hydratedTransactionToPayloadBundle,
   isAddressPairPayload,
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,