@xyo-network/xl1-protocol-sdk 1.15.2 → 1.15.4

package/dist/neutral/index.mjs

@@ -28,90 +28,12 @@ var flattenHydratedBlock = /* @__PURE__ */ __name((hydratedBlock) => {
 var flattenHydratedBlocks = /* @__PURE__ */ __name((hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk)), "flattenHydratedBlocks");
 
 // src/block/hydrate/hydrateBlock.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
-var hydrateBlock = /* @__PURE__ */ __name(async (archivist, 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");
-  assertEx2(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
-  const bw = assertEx2((await archivist.get([
-    hash
-  ])).find(isBlockBoundWitnessWithStorageMeta), () => `block ${hash} not found`);
-  if (maxDepth === 0) return [
-    bw,
-    []
-  ];
-  const blkPayloads = await archivist.get(bw.payload_hashes);
-  if (minDepth === 1) assertEx2(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
-  if (maxDepth === 1) return [
-    bw,
-    blkPayloads
-  ];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta2);
-  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
-  const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
-  assertEx2(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
-  const allPayloadsHashes = new Set([
-    ...blkPayloads,
-    ...transactionsPayloads
-  ].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([
-    ...allPayloadsHashes
-  ]);
-  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx2(allHashesPresent([
-    ...allPayloadsHashes
-  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
-  return [
-    bw,
-    allPayloadsFiltered
-  ];
-}, "hydrateBlock");
-
-// src/block/hydrate/transactionsFromHydratedBlock.ts
-import { filterAs } from "@xylabs/array";
-import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
-  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
-}, "transactionsFromHydratedBlock");
-
-// src/block/hydrate/tryHydrateBlock.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { isBlockBoundWitnessWithStorageMeta as isBlockBoundWitnessWithStorageMeta2, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
-var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
-  assertEx3(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  const bw = (await archivist.get([
-    hash
-  ])).find(isBlockBoundWitnessWithStorageMeta2);
-  if (!bw) return void 0;
-  if (maxDepth === 0) return [
-    bw,
-    []
-  ];
-  const blkPayloads = await archivist.get(bw.payload_hashes);
-  if (maxDepth === 1) return [
-    bw,
-    blkPayloads
-  ];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta3);
-  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
-  const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
-  const allPayloadsHashes = new Set([
-    ...blkPayloads,
-    ...transactionsPayloads
-  ].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([
-    ...allPayloadsHashes
-  ]);
-  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  return [
-    bw,
-    allPayloadsFiltered
-  ];
-}, "tryHydrateBlock");
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
 
 // src/block/primitives/balances/balancesStepSummaryFromRange.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx2 } from "@xylabs/assert";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { isAnyPayload } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
@@ -140,22 +62,17 @@ var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
 import { hexToBigInt as hexToBigInt2 } from "@xylabs/hex";
 import { span as span2 } from "@xylabs/telemetry";
 import { isTransfer as isTransfer2 } from "@xyo-network/xl1-protocol";
-function netTransfersForPayloads(payloads, account) {
+function netTransfersForPayloads(payloads) {
   return span2("netTransfersForPayloads", () => {
     const transfers = {};
     for (const payload of payloads) {
       if (isTransfer2(payload)) {
         const { from } = payload;
-        for (let [address, amount] of Object.entries(payload.transfers)) {
-          if (account === from) {
-            if (address !== from) {
-              transfers[address] = (transfers[address] ?? 0n) + hexToBigInt2(amount);
-            }
-          } else {
-            if (account === address) {
-              transfers[from] = (transfers[from] ?? 0n) - hexToBigInt2(amount);
-            }
-          }
+        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);
         }
       }
     }
@@ -275,10 +192,9 @@ import { asHash } from "@xylabs/hex";
 import { toSafeJsonString } from "@xylabs/object";
 import { asBlockBoundWitnessWithStorageMeta, StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
 async function blockFromBlockNumber(context, blockNumber) {
-  const result = await context.chainArchivist.get([
-    context.head
-  ]);
-  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, {
+  const head = await context.head();
+  const result = await context.store.chainMap.get(head);
+  let currentBlock = asBlockBoundWitnessWithStorageMeta(result, () => `Head block not found for hash: ${head}`, {
     required: true
   });
   while (currentBlock.block > blockNumber) {
@@ -291,9 +207,7 @@ async function blockFromBlockNumber(context, blockNumber) {
         jumpHash = asHash(currentBlock.step_hashes.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
       }
     }
-    const [newBlock] = await context.chainArchivist.get([
-      asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
-    ]);
+    const newBlock = await context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`));
     currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, {
       required: true
     });
@@ -343,51 +257,53 @@ var asTransfersStepSummaryWithStorageMeta = AsObjectFactory2.create(isTransfersS
 async function balancesStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
+  const head = await context.head();
   let result = void 0;
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0]);
-    const [, payloads] = await hydrateBlock(context.chainArchivist, hash);
+    const [, payloads] = await hydrateBlock(context.store, hash);
     const balances = {};
     for (const [address, balance] of Object.entries(netBalancesForPayloads(payloads))) {
       balances[address] = toSignedBigInt(balance);
     }
     result = {
       schema: BalancesStepSummarySchema,
-      hash: context.head,
+      hash: head,
       stepSize: -1,
       balances
     };
   } else {
     const step = StepSizes3.indexOf(frameSize);
-    assertEx4(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
-    const [summaryResult] = await context.summaryRepository.get([
-      frameHeadHash
-    ]);
+    assertEx2(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
     } else {
-      const subRanges = deepCalculateFramesFromRange(range, step - 1);
-      const promises = subRanges.map((subRange) => balancesStepSummaryFromRange(context, subRange));
-      const subResults = await Promise.all(promises);
-      const bigIntBalances = {};
-      for (const subResult of subResults) {
-        for (const [address, balance] of Object.entries(subResult.balances)) {
-          bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(balance);
+      await context.stepSemaphores[step].acquire();
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1);
+        const promises = subRanges.map((subRange) => balancesStepSummaryFromRange(context, subRange));
+        const subResults = await Promise.all(promises);
+        const bigIntBalances = {};
+        for (const subResult of subResults) {
+          for (const [address, balance] of Object.entries(subResult.balances)) {
+            bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(balance);
+          }
         }
+        const balances = {};
+        for (const [address, balance] of Object.entries(bigIntBalances)) {
+          balances[address] = toSignedBigInt(balance);
+        }
+        result = {
+          schema: BalancesStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: frameSize,
+          balances
+        };
+        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result);
+      } finally {
+        context.stepSemaphores[step].release();
       }
-      const balances = {};
-      for (const [address, balance] of Object.entries(bigIntBalances)) {
-        balances[address] = toSignedBigInt(balance);
-      }
-      result = {
-        schema: BalancesStepSummarySchema,
-        hash: frameHeadHash,
-        stepSize: frameSize,
-        balances
-      };
-      await context.summaryRepository.insert([
-        result
-      ]);
     }
   }
   const finalResult = await PayloadBuilder.addStorageMeta(result);
@@ -402,10 +318,9 @@ import { isDefined } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
 async function balancesSummary(context) {
   return await spanRootAsync("balanceSummary", async () => {
-    const headResult = await context.chainArchivist.get([
-      context.head
-    ]);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult.at(0), () => `Head block not found for hash: ${context.head}`, {
+    const head = await context.head();
+    const headResult = await context.store.chainMap.get(head);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult, () => `Head block not found for hash: ${context.head}`, {
       required: true
     });
     const rangeStart = isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0;
@@ -426,62 +341,76 @@ async function balancesSummary(context) {
 }
 __name(balancesSummary, "balancesSummary");
 
+// src/block/primitives/model.ts
+function isReadArchivist(obj) {
+  return obj.get !== void 0 && obj.next !== void 0;
+}
+__name(isReadArchivist, "isReadArchivist");
+
 // src/block/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol";
 async function transfersStepSummaryFromRange(context, range) {
   const frameHeadHash = await hashFromBlockNumber(context, range[1]);
   const frameSize = range[1] - range[0] + 1;
-  const { account } = context;
+  const head = await context.head();
   let result = void 0;
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0]);
-    const [, payloads] = await hydrateBlock(context.chainArchivist, hash);
+    const [, payloads] = await hydrateBlock(context.store, hash);
     const transfers = {};
-    for (const [address, balance] of Object.entries(netTransfersForPayloads(payloads, account))) {
-      transfers[address] = toSignedBigInt(balance);
+    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: context.head,
+      hash: head,
       stepSize: -1,
-      transfers,
-      account
+      transfers
     };
   } else {
     const step = StepSizes4.indexOf(frameSize);
-    assertEx5(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
-    const [summaryResult] = await context.summaryRepository.get([
-      frameHeadHash
-    ]);
+    assertEx3(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload2(summaryResult)) {
       result = summaryResult;
     } else {
-      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 [address, transfer] of Object.entries(subResult.transfers)) {
-          bigIntBalances[address] = (bigIntBalances[address] ?? 0n) + parseSignedBigInt(transfer);
+      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(`${frameHeadHash}|${frameSize}`, result);
+      } finally {
+        context.stepSemaphores[step].release();
       }
-      const transfers = {};
-      for (const [address, transfer] of Object.entries(bigIntBalances)) {
-        transfers[address] = toSignedBigInt(transfer);
-      }
-      result = {
-        schema: TransfersStepSummarySchema,
-        hash: frameHeadHash,
-        stepSize: frameSize,
-        transfers,
-        account
-      };
-      await context.summaryRepository.insert([
-        result
-      ]);
     }
   }
   const finalResult = await PayloadBuilder2.addStorageMeta(result);
@@ -496,10 +425,9 @@ import { isDefined as isDefined2 } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
 async function transfersSummary(context) {
   return await spanRootAsync2("transferSummary", async () => {
-    const headResult = await context.chainArchivist.get([
-      context.head
-    ]);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult.at(0), () => `Head block not found for hash: ${context.head}`, {
+    const head = await context.head();
+    const headResult = await context.store.chainMap.get(head);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${context.head}`, {
       required: true
     });
     const rangeStart = isDefined2(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0;
@@ -510,9 +438,13 @@ async function transfersSummary(context) {
     const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(context, range)));
     const transfers = {};
     for (let summary of summaries) {
-      for (const [address, transfer] of Object.entries(summary.transfers)) {
-        const validAddress = asAddress2(address, () => `Invalid address: ${address}`);
-        transfers[validAddress] = (transfers[validAddress] ?? 0n) + parseSignedBigInt(transfer);
+      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;
@@ -520,8 +452,108 @@ async function transfersSummary(context) {
 }
 __name(transfersSummary, "transfersSummary");
 
+// src/block/hydrate/hydrateBlock.ts
+function readPayloadMapFromStore(store) {
+  if (isReadArchivist(store)) {
+    return {
+      get: /* @__PURE__ */ __name(async (hash) => {
+        return (await store.get([
+          hash
+        ]))[0];
+      }, "get"),
+      getMany: /* @__PURE__ */ __name(async (hashes) => {
+        return await store.get(hashes);
+      }, "getMany"),
+      has: /* @__PURE__ */ __name(async (hash) => {
+        return isDefined3((await store.get([
+          hash
+        ]))[0]);
+      }, "has")
+    };
+  }
+  return store;
+}
+__name(readPayloadMapFromStore, "readPayloadMapFromStore");
+var hydrateBlock = /* @__PURE__ */ __name(async ({ chainMap }, hash, maxDepth = 1, minDepth = maxDepth) => {
+  assertEx4(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  assertEx4(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
+  assertEx4(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
+  const bw = assertEx4(asBlockBoundWitnessWithStorageMeta4(assertEx4(await chainMap.get(hash), () => `block ${hash} not found`)), () => `hash ${hash} is not a BlockBoundWitness`);
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
+  const blkPayloads = await chainMap.getMany(bw.payload_hashes);
+  if (minDepth === 1) assertEx4(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta2);
+  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
+  const transactionsPayloads = await chainMap.getMany(transactionsPayloadHashes);
+  assertEx4(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await chainMap.getMany([
+    ...allPayloadsHashes
+  ]);
+  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  if (maxDepth === 2) assertEx4(allHashesPresent([
+    ...allPayloadsHashes
+  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [
+    bw,
+    allPayloadsFiltered
+  ];
+}, "hydrateBlock");
+
+// src/block/hydrate/transactionsFromHydratedBlock.ts
+import { filterAs } from "@xylabs/array";
+import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
+  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
+}, "transactionsFromHydratedBlock");
+
+// src/block/hydrate/tryHydrateBlock.ts
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta3 } from "@xyo-network/xl1-protocol";
+var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
+  assertEx5(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  const bw = (await archivist.get([
+    hash
+  ])).find(isBlockBoundWitnessWithStorageMeta);
+  if (!bw) return void 0;
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
+  const blkPayloads = await archivist.get(bw.payload_hashes);
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta3);
+  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
+  const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await archivist.get([
+    ...allPayloadsHashes
+  ]);
+  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  return [
+    bw,
+    allPayloadsFiltered
+  ];
+}, "tryHydrateBlock");
+
 // src/config/Config.ts
-import * as z11 from "zod";
+import * as z12 from "zod";
 
 // src/config/Api.ts
 import { globalRegistry } from "zod";
@@ -586,11 +618,34 @@ var AppConfigZod = z3.object({
   })
 });
 
-// src/config/Chain.ts
+// src/config/Bridge.ts
 import { globalRegistry as globalRegistry3 } from "zod";
 import * as z4 from "zod";
-var ChainConfigZod = z4.object({
-  id: z4.string().optional().register(globalRegistry3, {
+var BridgeConfigZod = z4.object({
+  host: z4.string().default("localhost").register(globalRegistry3, {
+    default: "localhost",
+    description: "Host for the Bridge",
+    title: "api.host",
+    type: "string"
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry3, {
+    description: "Mnemonic for the Bridge wallet",
+    title: "api.mnemonic",
+    type: "string"
+  }),
+  port: z4.coerce.number().default(8081).register(globalRegistry3, {
+    default: 8081,
+    description: "Port for the Bridge",
+    title: "api.port",
+    type: "number"
+  })
+});
+
+// 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, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
     type: "string"
@@ -598,29 +653,29 @@ var ChainConfigZod = z4.object({
 });
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry4 } from "zod";
-import * as z5 from "zod";
-var EvmInfuraConfigZod = z5.object({
-  projectId: z5.string().optional().register(globalRegistry4, {
+import { globalRegistry as globalRegistry5 } from "zod";
+import * as z6 from "zod";
+var EvmInfuraConfigZod = z6.object({
+  projectId: z6.string().optional().register(globalRegistry5, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z5.string().optional().register(globalRegistry4, {
+  projectSecret: z6.string().optional().register(globalRegistry5, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z5.object({
-  url: z5.url().optional().register(globalRegistry4, {
+var EvmJsonRpcConfigZod = z6.object({
+  url: z6.url().optional().register(globalRegistry5, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z5.object({
-  chainId: z5.string().optional().register(globalRegistry4, {
+var EvmConfigZod = z6.object({
+  chainId: z6.string().optional().register(globalRegistry5, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -631,18 +686,18 @@ var EvmConfigZod = z5.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/logger";
-import { globalRegistry as globalRegistry5 } from "zod";
-import * as z6 from "zod";
+import { globalRegistry as globalRegistry6 } from "zod";
+import * as z7 from "zod";
 var LogLevels = Object.keys(LogLevel);
-var LogConfigZod = z6.object({
-  logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
+var LogConfigZod = z7.object({
+  logLevel: z7.enum(LogLevels).default("info").register(globalRegistry6, {
     choices: LogLevels,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z6.boolean().default(false).register(globalRegistry5, {
+  silent: z7.boolean().default(false).register(globalRegistry6, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -652,55 +707,55 @@ var LogConfigZod = z6.object({
 
 // src/config/Producer.ts
 import { AddressZod, asAddress as asAddress3 } from "@xylabs/hex";
-import { globalRegistry as globalRegistry6 } from "zod";
-import * as z7 from "zod";
-var ProducerConfigZod = z7.object({
-  allowlist: z7.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;
-  }, z7.array(AddressZod).optional().register(globalRegistry6, {
+  }, z8.array(AddressZod).optional().register(globalRegistry7, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  disableIntentRedeclaration: z7.boolean().optional().register(globalRegistry6, {
+  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: z7.coerce.number().optional().register(globalRegistry6, {
+  healthCheckPort: z8.coerce.number().optional().register(globalRegistry7, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
   }),
-  heartbeatInterval: z7.coerce.number().default(36e5).register(globalRegistry6, {
+  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: z7.coerce.number().default(1).register(globalRegistry6, {
+  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(globalRegistry6, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
     description: "Mnemonic for the Producer wallet",
     title: "producer.mnemonic",
     type: "string"
   }),
   // TODO: Port schema
-  port: z7.coerce.number().default(8081).register(globalRegistry6, {
+  port: z8.coerce.number().default(8081).register(globalRegistry7, {
     default: 8081,
     description: "Port for the Producer",
     title: "producer.port",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z7.string().optional().register(globalRegistry6, {
+  rewardAddress: z8.string().optional().register(globalRegistry7, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -708,36 +763,36 @@ var ProducerConfigZod = z7.object({
 });
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined3, isUndefined } from "@xylabs/typeof";
-import { globalRegistry as globalRegistry7 } from "zod";
-import * as z8 from "zod";
+import { isDefined as isDefined4, isUndefined } from "@xylabs/typeof";
+import { globalRegistry as globalRegistry8 } from "zod";
+import * as z9 from "zod";
 var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined(config)) return false;
-  return isDefined3(config.connectionString) && isDefined3(config.database) && isDefined3(config.domain) && isDefined3(config.password) && isDefined3(config.username);
+  return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain) && isDefined4(config.password) && isDefined4(config.username);
 }, "hasMongoConfig");
-var MongoConfigZod = z8.object({
+var MongoConfigZod = z9.object({
   // TODO: Create from other arguments
-  connectionString: z8.string().min(1).optional().register(globalRegistry7, {
+  connectionString: z9.string().min(1).optional().register(globalRegistry8, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z8.string().min(1).optional().register(globalRegistry7, {
+  database: z9.string().min(1).optional().register(globalRegistry8, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z8.string().min(1).optional().register(globalRegistry7, {
+  domain: z9.string().min(1).optional().register(globalRegistry8, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z8.string().min(1).optional().register(globalRegistry7, {
+  password: z9.string().min(1).optional().register(globalRegistry8, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z8.string().min(1).optional().register(globalRegistry7, {
+  username: z9.string().min(1).optional().register(globalRegistry8, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -745,11 +800,11 @@ var MongoConfigZod = z8.object({
 });
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry8 } from "zod";
-import * as z9 from "zod";
-var StorageConfigZod = z9.object({
+import { globalRegistry as globalRegistry9 } from "zod";
+import * as z10 from "zod";
+var StorageConfigZod = z10.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z9.string().optional().register(globalRegistry8, {
+  root: z10.string().optional().register(globalRegistry9, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -757,29 +812,30 @@ var StorageConfigZod = z9.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
-var OpenTelemetryConfigZod = z10.object({
+import { globalRegistry as globalRegistry10 } from "zod";
+import * as z11 from "zod";
+var OpenTelemetryConfigZod = z11.object({
   // OpenTelemetry options
-  otlpEndpoint: z10.url().optional().register(globalRegistry9, {
+  otlpEndpoint: z11.url().optional().register(globalRegistry10, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z10.object({
+var TelemetryConfigZod = z11.object({
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
 // src/config/Config.ts
-var Xl1CommonConfigSchema = z11.object({
+var Xl1CommonConfigSchema = z12.object({
   ...LogConfigZod.shape
 }).describe("XL1 common configuration options");
-var ConfigZod = z11.object({
+var ConfigZod = z12.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"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
@@ -789,35 +845,35 @@ var ConfigZod = z11.object({
 var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
 
 // src/config/UsageMeta.ts
-import * as z12 from "zod";
-var DescriptionSchema = z12.string();
-var TitleSchema = z12.string();
-var JSONSchemaMetaSchema = z12.object({
-  id: z12.string().optional(),
+import * as z13 from "zod";
+var DescriptionSchema = z13.string();
+var TitleSchema = z13.string();
+var JSONSchemaMetaSchema = z13.object({
+  id: z13.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z12.boolean().optional()
-}).catchall(z12.unknown());
+  deprecated: z13.boolean().optional()
+}).catchall(z13.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z12.array(z12.union([
-  z12.string(),
-  z12.number(),
-  z12.literal(true),
-  z12.undefined()
+var ChoicesSchema = z13.array(z13.union([
+  z13.string(),
+  z13.number(),
+  z13.literal(true),
+  z13.undefined()
 ])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z12.unknown().optional(),
+  default: z13.unknown().optional(),
   description: DescriptionSchema,
-  group: z12.string().optional(),
-  hidden: z12.boolean().optional(),
+  group: z13.string().optional(),
+  hidden: z13.boolean().optional(),
   title: TitleSchema,
-  type: z12.union([
-    z12.literal("array"),
-    z12.literal("count"),
-    z12.literal("boolean"),
-    z12.literal("number"),
-    z12.literal("string")
+  type: z13.union([
+    z13.literal("array"),
+    z13.literal("count"),
+    z13.literal("boolean"),
+    z13.literal("number"),
+    z13.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -825,6 +881,13 @@ function isUsageMeta(v) {
 }
 __name(isUsageMeta, "isUsageMeta");
 
+// src/model/StakeEvents.ts
+var StakeEventNames = [
+  "StakeAdded",
+  "StakeRemoved",
+  "StakeWithdrawn"
+];
+
 // src/steps/primitives/addressStakeWeight.ts
 import { toAddress as toAddress2 } from "@xylabs/hex";
 import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-protocol";
@@ -879,70 +942,6 @@ function claimedRewards(_address) {
 }
 __name(claimedRewards, "claimedRewards");
 
-// src/steps/primitives/networkStakeStepAddressReward.ts
-function networkStakeStepAddressReward(address, _step, _block) {
-  return {
-    [address]: 0n
-  };
-}
-__name(networkStakeStepAddressReward, "networkStakeStepAddressReward");
-
-// src/steps/primitives/networkStakeStepPoolRewards.ts
-function networkStakeStepPoolRewards(_step, _block) {
-  return {};
-}
-__name(networkStakeStepPoolRewards, "networkStakeStepPoolRewards");
-
-// src/steps/primitives/networkStakeStepPoolRewardShares.ts
-function networkStakeStepPoolRewardShares(_step, _block) {
-  return {};
-}
-__name(networkStakeStepPoolRewardShares, "networkStakeStepPoolRewardShares");
-
-// src/steps/primitives/networkStakeStepRewardAddressHistory.ts
-function networkStakeStepRewardAddressHistory(address) {
-  return {
-    [address]: 0n
-  };
-}
-__name(networkStakeStepRewardAddressHistory, "networkStakeStepRewardAddressHistory");
-
-// src/steps/primitives/networkStakeStepRewardAddressShare.ts
-function networkStakeStepRewardAddressShare(_address, _step, _block) {
-  throw new Error("Method not implemented.");
-}
-__name(networkStakeStepRewardAddressShare, "networkStakeStepRewardAddressShare");
-
-// src/steps/primitives/networkStakeStepRewardForStep.ts
-function networkStakeStepRewardForStep(_step) {
-  return 0n;
-}
-__name(networkStakeStepRewardForStep, "networkStakeStepRewardForStep");
-
-// src/steps/primitives/networkStakeStepRewardPositionWeight.ts
-function networkStakeStepRewardPositionWeight(_position, _step) {
-  throw new Error("Method not implemented.");
-}
-__name(networkStakeStepRewardPositionWeight, "networkStakeStepRewardPositionWeight");
-
-// src/steps/primitives/networkStakeStepRewardPotentialPositionLoss.ts
-function networkStakeStepRewardPotentialPositionLoss(_position, _step) {
-  throw new Error("Method not implemented.");
-}
-__name(networkStakeStepRewardPotentialPositionLoss, "networkStakeStepRewardPotentialPositionLoss");
-
-// src/steps/primitives/networkStakeStepRewardRandomizer.ts
-function networkStakeStepRewardRandomizer(_step, _block) {
-  throw new Error("Method not implemented.");
-}
-__name(networkStakeStepRewardRandomizer, "networkStakeStepRewardRandomizer");
-
-// src/steps/primitives/networkStakeStepRewardWeightForAddress.ts
-function networkStakeStepRewardWeightForAddress(_address, _step) {
-  throw new Error("Method not implemented.");
-}
-__name(networkStakeStepRewardWeightForAddress, "networkStakeStepRewardWeightForAddress");
-
 // src/steps/primitives/stakersAsOfBlock.ts
 import { toAddress as toAddress4 } from "@xylabs/hex";
 
@@ -1038,7 +1037,7 @@ import { assertEx as assertEx6 } from "@xylabs/assert";
 import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
-  const hydratedBlock = await hydrateBlock(context.chainArchivist, blockHash);
+  const hydratedBlock = await hydrateBlock(context.store, blockHash);
   const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
     required: true
   });
@@ -1138,7 +1137,7 @@ __name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
-import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { isDefined as isDefined5 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
@@ -1149,7 +1148,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
   let attempts = 0;
   while (true) {
     const tx = await viewer.transactionByHash(txBWHash) ?? void 0;
-    if (isDefined4(tx)) {
+    if (isDefined5(tx)) {
       options?.logger?.log("\u2705 Transaction confirmed:", txBWHash, "\n");
       return tx;
     } else {
@@ -1169,11 +1168,25 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
 import { assertEx as assertEx8 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
 import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
-var tryHydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
-  return await tryHydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+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 (archivist, hash) => {
-  return await hydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+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;
@@ -1183,8 +1196,10 @@ var flattenHydratedTransaction = /* @__PURE__ */ __name((hydratedTransaction) =>
   ];
 }, "flattenHydratedTransaction");
 var flattenHydratedTransactions = /* @__PURE__ */ __name((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
-var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
-  const hydratedTransaction = await tryHydrateTransaction(archivist, hash);
+var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
+  const hydratedTransaction = await tryHydrateTransaction({
+    chainMap
+  }, hash);
   if (!hydratedTransaction) {
     return void 0;
   }
@@ -1208,8 +1223,8 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, has
   }
   return void 0;
 }, "tryHydrateElevatedTransaction");
-var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
-  return assertEx8(await tryHydrateElevatedTransaction(archivist, hash), () => "Hydration failed");
+var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
+  return assertEx8(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -1365,6 +1380,7 @@ export {
   GlobalMetaSchema,
   JSONSchemaMetaSchema,
   MnemonicStringZod,
+  StakeEventNames,
   StepSummarySchema,
   TODO,
   TransfersStepSummarySchema,
@@ -1408,22 +1424,14 @@ export {
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
+  isReadArchivist,
   isTransfersStepSummary,
   isTransfersStepSummaryWithStorageMeta,
   isUsageMeta,
   netBalancesForPayloads,
   netTransfersForPayloads,
-  networkStakeStepAddressReward,
-  networkStakeStepPoolRewardShares,
-  networkStakeStepPoolRewards,
-  networkStakeStepRewardAddressHistory,
-  networkStakeStepRewardAddressShare,
-  networkStakeStepRewardForStep,
-  networkStakeStepRewardPositionWeight,
-  networkStakeStepRewardPotentialPositionLoss,
-  networkStakeStepRewardRandomizer,
-  networkStakeStepRewardWeightForAddress,
   parseSignedBigInt,
+  readPayloadMapFromStore,
   signTransaction,
   stakersAsOfBlock,
   startingStakes,