@xyo-network/chain-services 1.8.3 → 1.9.0

package/dist/neutral/index.mjs

@@ -370,7 +370,7 @@ BaseBlockRewardService = _ts_decorate4([
 // src/BlockReward/EvmBlockRewardService.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { creatable as creatable5 } from "@xylabs/creatable";
-import { toEthAddress } from "@xyo-network/chain-ethereum";
+import { toEthAddress } from "@xylabs/hex";
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from "@xyo-network/typechain";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -552,8 +552,7 @@ var ChainBlockNumberIterationService = class extends BaseService {
 
 // src/ChainService/Evm/Evm.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
-import { toAddress } from "@xylabs/hex";
-import { toEthAddress as toEthAddress2 } from "@xyo-network/chain-ethereum";
+import { toAddress, toEthAddress as toEthAddress2 } from "@xylabs/hex";
 import { StakedXyoChain__factory as StakedXyoChainFactory } from "@xyo-network/typechain";
 import { getAddress } from "ethers/address";
 var EvmChainService = class extends BaseService {
@@ -743,11 +742,188 @@ XyoValidator = _ts_decorate7([
   creatable7()
 ], XyoValidator);
 
-// src/Election/BaseElectionService.ts
+// src/DataLake/AbstractXyoDataLake.ts
+import { ObjectHasher } from "@xyo-network/hash";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { isAnyPayload } from "@xyo-network/payload-model";
+import { isHashPayload } from "@xyo-network/xl1-protocol";
+var AbstractXyoDataLake = class {
+  static {
+    __name(this, "AbstractXyoDataLake");
+  }
+  async fetch(hashes, maxDepth = 10) {
+    const results = await this.get(hashes);
+    if (maxDepth > 0) {
+      const hashPayloads = results.filter(isHashPayload);
+      const otherPayloads = results.filter((item) => !isHashPayload(item));
+      const found = await this.fetch(hashPayloads.map((item) => item.hash), maxDepth - 1);
+      const foundHashes = await Promise.all(found.map(async (item) => isAnyPayload(item) ? await PayloadBuilder4.hash(item) : ObjectHasher.hashBytes(item)));
+      const notFound = hashPayloads.filter((item) => !foundHashes.includes(item.hash));
+      return [
+        ...otherPayloads,
+        ...found,
+        ...notFound
+      ];
+    }
+    return results;
+  }
+  async trace(hash) {
+    const [result] = await this.get([
+      hash
+    ]);
+    if (isHashPayload(result)) {
+      const [payload, route] = await this.trace(result.hash);
+      return [
+        payload,
+        [
+          result,
+          ...route
+        ]
+      ];
+    }
+    return [
+      result,
+      []
+    ];
+  }
+};
+
+// src/DataLake/ArchivistXyoDataLake.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
+import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
+var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
+  static {
+    __name(this, "ArchivistXyoDataLake");
+  }
+  _archivist;
+  constructor(archivist) {
+    super();
+    this._archivist = archivist;
+  }
+  async add(items) {
+    const payloads = items.filter(isAnyPayload2);
+    assertEx8(payloads.length === items.length, () => "Some items are not payloads");
+    return await this._archivist.insert(payloads);
+  }
+  async get(hashes) {
+    return await this._archivist.get(hashes);
+  }
+};
+
+// src/DataLake/HttpXyoDataLake.ts
+import { assertEx as assertEx9 } from "@xylabs/assert";
+import { AxiosJson } from "@xylabs/axios";
+import { exists as exists3 } from "@xylabs/exists";
+import { isArrayBuffer, isDefined as isDefined2 } from "@xylabs/typeof";
+import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
+import { isHashPayload as isHashPayload2 } from "@xyo-network/xl1-protocol";
+import { Axios } from "axios";
+var HttpXyoDataLake = class extends AbstractXyoDataLake {
+  static {
+    __name(this, "HttpXyoDataLake");
+  }
+  _axiosGet;
+  _axiosInsertBlob;
+  _axiosInsertJson;
+  _endpoint;
+  constructor(endpoint) {
+    super();
+    this._endpoint = endpoint;
+    this._axiosInsertJson = new AxiosJson({
+      baseURL: endpoint
+    });
+    this._axiosInsertBlob = new Axios({
+      baseURL: endpoint,
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "Accept": "application/octet-stream"
+      }
+    });
+    this._axiosGet = new Axios({
+      baseURL: endpoint,
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/octet-stream, application/json"
+      }
+    });
+  }
+  get endpoint() {
+    return this._endpoint;
+  }
+  async add(items) {
+    const results = [];
+    for (const item of items) {
+      if (isAnyPayload3(item)) {
+        const result = await this.addPayload(item);
+        if (isAnyPayload3(result)) {
+          results.push(result);
+        } else if (isDefined2(result)) {
+          assertEx9(false, () => "Expected result to be a Payload");
+        }
+      } else if (isArrayBuffer(item)) {
+        const result = await this.addArrayBuffer(item);
+        if (isAnyPayload3(result)) {
+          results.push(result);
+        } else if (isDefined2(result)) {
+          assertEx9(false, () => "Expected result to be a Payload");
+        }
+      }
+    }
+    return results;
+  }
+  async get(hashes) {
+    return (await Promise.all(hashes.map(async (hash) => {
+      return await this.getOne(hash);
+    }))).filter(exists3);
+  }
+  async addArrayBuffer(item) {
+    const result = await this._axiosInsertBlob.post("/insert", item);
+    if (result.status < 200 || result.status >= 300) {
+      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
+    }
+    if (!isArrayBuffer(result.data)) {
+      throw new Error("Invalid response from server (expected a ArrayBuffer)");
+    }
+    return result.data;
+  }
+  async addPayload(item) {
+    const result = await this._axiosInsertJson.post("/insert", item);
+    if (result.status < 200 || result.status >= 300) {
+      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
+    }
+    if (!isAnyPayload3(result.data)) {
+      throw new Error("Invalid response from server (expected a Payload)");
+    }
+    return result.data;
+  }
+  async fetchOne(hash, maxDepth = Number.MAX_SAFE_INTEGER) {
+    if (maxDepth <= 0) {
+      return void 0;
+    }
+    const result = await this.getOne(hash);
+    if (isHashPayload2(result)) {
+      return await this.fetchOne(result.hash, maxDepth - 1);
+    }
+    return result;
+  }
+  getOne(hash) {
+    return this._axiosGet.get(`/get/${hash}`).then((response) => {
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(`Failed to get item [${response.status}]: ${response.statusText}`);
+      }
+      if (!isAnyPayload3(response.data)) {
+        throw new Error("Invalid response from server (expected a Payload)");
+      }
+      return response.data;
+    });
+  }
+};
+
+// src/Election/BaseElectionService.ts
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { creatable as creatable8 } from "@xylabs/creatable";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -760,19 +936,19 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx8(this.params.chainIterator, () => "No chain iterator");
+    return assertEx10(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx8(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx8(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx10(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
       const nextBlock = current.block + 1;
       const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, "producer");
-      const previousBlockHash = await PayloadBuilder4.hash(current);
+      const previousBlockHash = await PayloadBuilder5.hash(current);
       return this.generateCreatorCommittee(candidates, previousBlockHash);
     });
   }
@@ -790,11 +966,11 @@ BaseElectionService = _ts_decorate8([
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx11 } from "@xylabs/assert";
 import { creatable as creatable9 } from "@xylabs/creatable";
-import { exists as exists3 } from "@xylabs/exists";
+import { exists as exists4 } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
-import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
+import { isDefined as isDefined3, isUndefined } from "@xylabs/typeof";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
 import { findMostRecentBlock } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
@@ -802,10 +978,10 @@ import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-networ
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/PendingTransactions/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload) => {
-  const withStorageMeta = await PayloadBuilder5.addStorageMeta(payload.payloads);
+  const withStorageMeta = await PayloadBuilder6.addStorageMeta(payload.payloads);
   const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
@@ -816,7 +992,7 @@ var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name(async (payload)
 }, "bundledPayloadToHydratedTransaction");
 
 // src/PendingTransactions/hydratedTransactionToPayloadBundle.ts
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) => {
@@ -824,8 +1000,8 @@ var hydratedTransactionToPayloadBundle = /* @__PURE__ */ __name((transaction) =>
   return bundle(root, transaction);
 }, "hydratedTransactionToPayloadBundle");
 var bundle = /* @__PURE__ */ __name((root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
-  return new PayloadBuilder6({
+  const payloads = flattenHydratedTransaction(transaction).flatMap((p) => PayloadBuilder7.omitStorageMeta(p));
+  return new PayloadBuilder7({
     schema: PayloadBundleSchema
   }).fields({
     payloads,
@@ -885,23 +1061,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   */
   _updateCuratedPendingTransactionsArchivistMutex = new Mutex2();
   get chainArchivist() {
-    return assertEx9(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx9(this.params.chainId, () => "No chain id");
+    return assertEx11(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx9(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx11(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
   get rejectedTransactionsArchivist() {
-    return assertEx9(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx11(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -947,7 +1123,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           if (pendingBundledTransactions.length === 0) break;
           cursor = pendingBundledTransactions.at(-1)?._sequence;
           const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists3);
+          const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists4);
           const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
           foundPendingTransactions.push(...activeTransactions);
         }
@@ -964,7 +1140,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
   async cleanupWorker() {
     return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
       const lastHead = await findMostRecentBlock(this.chainArchivist);
-      if (isDefined2(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
+      if (isDefined3(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
     }, _BasePendingTransactionsService.MutexPriority.PurgeTransactions);
   }
   async countPendingTransactions() {
@@ -988,7 +1164,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
         const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
           return await bundledPayloadToHydratedTransaction(tx);
-        }))).filter(exists3);
+        }))).filter(exists4);
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
           const errors = await validateTransaction(tx, this.chainId, [
             TransactionJsonSchemaValidator
@@ -1024,7 +1200,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       let [lastHead] = filterAs(await this.chainArchivist.get([
         head
       ]), asBlockBoundWitnessWithHashStorageMeta);
-      while (isDefined2(lastHead)) {
+      while (isDefined3(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
           order: "asc",
@@ -1035,14 +1211,14 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         }
         cursor = pendingBundledTransactions.at(-1)?._sequence;
         const deletedTransactionBundles = pendingBundledTransactions.filter((tx) => this._removablePendingTransactionHashes.has(tx.root));
-        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists3));
+        foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists4));
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
-        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists3);
+        const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists4);
         const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1));
         const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
           // Find the corresponding payload bundle hash for the expired transaction
           pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
-        )).filter(exists3);
+        )).filter(exists4);
         foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes);
       }
       const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes);
@@ -1066,7 +1242,7 @@ var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf
 
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { exists as exists4 } from "@xylabs/exists";
+import { exists as exists5 } from "@xylabs/exists";
 import { asOptionalBoundWitness } from "@xyo-network/boundwitness-model";
 import { payloadSchemasContains } from "@xyo-network/boundwitness-validator";
 import { BoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
@@ -1077,7 +1253,7 @@ var getBlockSignedStakeDeclarations = /* @__PURE__ */ __name(async (block, archi
   const bwsFromBlockWithDeclarations = bwsFromBlock.filter((bw) => payloadSchemasContains(bw, ChainStakeIntentSchema));
   const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations);
   return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
-    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists4);
+    const stakeIntentHashes = validBlockBwsWithDeclarations.flatMap(mapBoundWitnessToStakeIntentHashes).filter(exists5);
     const payloads = await archivist.get(stakeIntentHashes);
     const stakeIntents = filterAs2(payloads, asChainStakeIntent).filter((p) => p.intent === intent).filter((p) => bw.addresses.includes(p.from));
     return stakeIntents;
@@ -1093,13 +1269,13 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 
 // src/StakeIntent/XyoStakeIntentService.ts
 import { filterAs as filterAs3 } from "@xylabs/array";
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx12 } from "@xylabs/assert";
 import { creatable as creatable10 } from "@xylabs/creatable";
 import { asAddress } from "@xylabs/hex";
 import { isUndefined as isUndefined2 } from "@xylabs/typeof";
 import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
 import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent as asChainStakeIntent2, ChainIndexingServiceStateSchema, isChainIndexingServiceState } from "@xyo-network/xl1-protocol";
 import { Mutex as Mutex3 } from "async-mutex";
 import { LRUCache as LRUCache3 } from "lru-cache";
@@ -1132,16 +1308,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx10(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx10(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx10(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1149,18 +1325,18 @@ var XyoStakeIntentService = class extends BaseService {
     });
     const head = await this.chainIterator.head();
     if (isUndefined2(head)) return;
-    const headHash = await PayloadBuilder7.hash(head);
+    const headHash = await PayloadBuilder8.hash(head);
     await this.recoverState(headHash);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+    assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
     const results = this._producers.get(address);
     return results ?? [];
   }
   async getDeclaredCandidatesForBlock(block, intent) {
     return await this.spanAsync("getDeclaredCandidatesForBlock", async () => {
-      assertEx10(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
+      assertEx12(intent === "producer", () => `Error: Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1214,7 +1390,7 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async persistState(current) {
     const state = this._producers.serialize();
-    const payload = new PayloadBuilder7({
+    const payload = new PayloadBuilder8({
       schema: ChainIndexingServiceStateSchema
     }).fields({
       endBlockHash: current,
@@ -1225,7 +1401,7 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx10(asBlockBoundWitness3((await this.chainArchivist.get([
+    const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
       current
     ]))?.[0]), () => `Block ${current} not found`);
     const currentBlockNum = currentBlock.block;
@@ -1266,7 +1442,7 @@ var XyoStakeIntentService = class extends BaseService {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
         if (isUndefined2(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
+        const currentHeadHash = await PayloadBuilder8.hash(currentHead);
         const result = await analyzeChain(this.chainArchivist, [
           new ChainStakeIntentAnalyzer("producer")
         ], currentHeadHash, this._lastIndexedBlockHash);
@@ -1291,137 +1467,9 @@ var XyoStakeIntentService = class extends BaseService {
 XyoStakeIntentService = _ts_decorate10([
   creatable10()
 ], XyoStakeIntentService);
-
-// src/XyoDataLake.ts
-import { assertEx as assertEx11 } from "@xylabs/assert";
-import { AxiosJson } from "@xylabs/axios";
-import { exists as exists5 } from "@xylabs/exists";
-import { isArrayBuffer, isDefined as isDefined3 } from "@xylabs/typeof";
-import { isAnyPayload } from "@xyo-network/payload-model";
-import { isHashPayload } from "@xyo-network/xl1-protocol";
-import { Axios } from "axios";
-var XyoDataLake = class {
-  static {
-    __name(this, "XyoDataLake");
-  }
-  _axiosGet;
-  _axiosInsertBlob;
-  _axiosInsertJson;
-  _endpoint;
-  constructor(endpoint) {
-    this._endpoint = endpoint;
-    this._axiosInsertJson = new AxiosJson({
-      baseURL: endpoint
-    });
-    this._axiosInsertBlob = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Accept": "application/octet-stream"
-      }
-    });
-    this._axiosGet = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/octet-stream, application/json"
-      }
-    });
-  }
-  get endpoint() {
-    return this._endpoint;
-  }
-  async add(items) {
-    const results = [];
-    for (const item of items) {
-      if (isAnyPayload(item)) {
-        const result = await this.addPayload(item);
-        if (isAnyPayload(result)) {
-          results.push(result);
-        } else if (isDefined3(result)) {
-          assertEx11(false, () => "Expected result to be a Payload");
-        }
-      } else if (isArrayBuffer(item)) {
-        const result = await this.addArrayBuffer(item);
-        if (isAnyPayload(result)) {
-          results.push(result);
-        } else if (isDefined3(result)) {
-          assertEx11(false, () => "Expected result to be a Payload");
-        }
-      }
-    }
-    return results;
-  }
-  async fetch(hashes, maxDepth) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      return await this.fetchOne(hash, maxDepth);
-    }))).filter(exists5);
-  }
-  async get(hashes) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      return await this.getOne(hash);
-    }))).filter(exists5);
-  }
-  async trace(hash) {
-    const result = await this.getOne(hash);
-    if (isHashPayload(result)) {
-      const [payload, route] = await this.trace(result.hash);
-      return [
-        payload,
-        [
-          result,
-          ...route
-        ]
-      ];
-    }
-    return [
-      result,
-      []
-    ];
-  }
-  async addArrayBuffer(item) {
-    const result = await this._axiosInsertBlob.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!isArrayBuffer(result.data)) {
-      throw new Error("Invalid response from server (expected a ArrayBuffer)");
-    }
-    return result.data;
-  }
-  async addPayload(item) {
-    const result = await this._axiosInsertJson.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!isAnyPayload(result.data)) {
-      throw new Error("Invalid response from server (expected a Payload)");
-    }
-    return result.data;
-  }
-  async fetchOne(hash, maxDepth = Number.MAX_SAFE_INTEGER) {
-    if (maxDepth <= 0) {
-      return void 0;
-    }
-    const result = await this.getOne(hash);
-    if (isHashPayload(result)) {
-      return await this.fetchOne(result.hash, maxDepth - 1);
-    }
-    return result;
-  }
-  getOne(hash) {
-    return this._axiosGet.get(`/get/${hash}`).then((response) => {
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`Failed to get item [${response.status}]: ${response.statusText}`);
-      }
-      if (!isAnyPayload(response.data)) {
-        throw new Error("Invalid response from server (expected a Payload)");
-      }
-      return response.data;
-    });
-  }
-};
 export {
+  AbstractXyoDataLake,
+  ArchivistXyoDataLake,
   BaseAccountBalanceService,
   BaseAccountableService,
   BaseBlockProducerService,
@@ -1433,11 +1481,11 @@ export {
   DEFAULT_BLOCK_SIZE,
   EvmBlockRewardService,
   EvmChainService,
+  HttpXyoDataLake,
   MemoryBlockRewardService,
   MemoryChainService,
   XYO_PRODUCER_REDECLARATION_DURATION,
   XYO_PRODUCER_REDECLARATION_WINDOW,
-  XyoDataLake,
   XyoStakeIntentService,
   XyoValidator,
   accountBalanceServiceFromArchivist,