@xyo-network/xl1-protocol-sdk 1.22.29 → 1.22.30

package/dist/neutral/index.mjs

@@ -4245,13 +4245,128 @@ var SimpleXyoClient = class {
   }
 };
 
-// src/simple/datalake/SimpleDataLakeRunner.ts
+// src/simple/datalake/RestDataLakeRunner.ts
+import {
+  assertEx as assertEx36,
+  exists as exists6
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload5 } from "@xyo-network/payload-model";
 import {
   DataLakeRunnerMoniker
 } from "@xyo-network/xl1-protocol";
 
+// src/simple/datalake/AbstractRestDataLake.ts
+import { axiosJsonConfig } from "@xylabs/axios";
+import { exists as exists5 } from "@xylabs/sdk-js";
+import {
+  isAnyPayload as isAnyPayload4
+} from "@xyo-network/payload-model";
+import { Axios } from "axios";
+var AbstractRestDataLake = class extends AbstractCreatableProvider {
+  get allowedSchemas() {
+    return this.params.allowedSchemas;
+  }
+  get axios() {
+    return new Axios(axiosJsonConfig());
+  }
+  get disallowedSchemas() {
+    return this.params.disallowedSchemas;
+  }
+  get endpoint() {
+    return this.params.endpoint;
+  }
+  async get(hash) {
+    const { data } = await this.axios.get(`${this.params.endpoint}/get/${hash}`);
+    return (this.isAllowed(data) ? data : void 0) ?? void 0;
+  }
+  async getMany(hashes) {
+    return (await Promise.all(hashes.map((hash) => this.get(hash)))).filter(exists5);
+  }
+  async has(hash) {
+    const value = await this.get(hash);
+    if (isAnyPayload4(value)) {
+      return this.isAllowed(value);
+    }
+    return !!await this.get(hash);
+  }
+  isAllowed(value) {
+    if (isAnyPayload4(value)) {
+      return this.isAllowedSchema(value.schema);
+    }
+    return false;
+  }
+  isAllowedSchema(schema) {
+    if (this.allowedSchemas && !this.allowedSchemas.includes(schema)) {
+      return false;
+    }
+    if (this.disallowedSchemas && this.disallowedSchemas.includes(schema)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/simple/datalake/RestDataLakeRunner.ts
+var RestDataLakeRunner = class extends AbstractRestDataLake {
+  moniker = RestDataLakeRunner.defaultMoniker;
+  clear() {
+    throw new Error("Clear is not supported on RestDataLakeRunner");
+  }
+  delete(_hash) {
+    throw new Error("Delete is not supported on RestDataLakeRunner");
+  }
+  async set(hash, data) {
+    if (isAnyPayload5(data) && this.isAllowed(data)) {
+      const actualHash = await PayloadBuilder18.hash(data);
+      assertEx36(actualHash === hash, () => `Hash of data does not match provided hash. Expected ${hash}, got ${actualHash}`);
+      assertEx36(typeof data === "object" && data !== null, () => "Data must be an object");
+      const result = await this.axios.post(`${this.params.endpoint}/insert`, data);
+      return result.status === 200 ? actualHash : void 0;
+    }
+  }
+  async setMany(entries) {
+    const data = entries.map(([, data2]) => {
+      if (isAnyPayload5(data2) && this.isAllowed(data2)) {
+        assertEx36(typeof data2 === "object" && data2 !== null, () => "Data must be an object");
+        return data2;
+      }
+      return null;
+    }).filter(exists6);
+    if (data.length > 0) {
+      const result = await this.axios.post(`${this.params.endpoint}/insert`, data);
+      return result.data;
+    }
+  }
+};
+__publicField(RestDataLakeRunner, "defaultMoniker", DataLakeRunnerMoniker);
+__publicField(RestDataLakeRunner, "dependencies", []);
+__publicField(RestDataLakeRunner, "monikers", [DataLakeRunnerMoniker]);
+RestDataLakeRunner = __decorateClass([
+  creatableProvider()
+], RestDataLakeRunner);
+
+// src/simple/datalake/RestDataLakeViewer.ts
+import {
+  DataLakeViewerMoniker
+} from "@xyo-network/xl1-protocol";
+var RestDataLakeViewer = class extends AbstractRestDataLake {
+  moniker = RestDataLakeViewer.defaultMoniker;
+};
+__publicField(RestDataLakeViewer, "defaultMoniker", DataLakeViewerMoniker);
+__publicField(RestDataLakeViewer, "dependencies", []);
+__publicField(RestDataLakeViewer, "monikers", [DataLakeViewerMoniker]);
+RestDataLakeViewer = __decorateClass([
+  creatableProvider()
+], RestDataLakeViewer);
+
+// src/simple/datalake/SimpleDataLakeRunner.ts
+import {
+  DataLakeRunnerMoniker as DataLakeRunnerMoniker2
+} from "@xyo-network/xl1-protocol";
+
 // src/simple/datalake/AbstractSimpleDataLake.ts
-import { isAnyPayload as isAnyPayload4 } from "@xyo-network/payload-model";
+import { isAnyPayload as isAnyPayload6 } from "@xyo-network/payload-model";
 var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
   get allowedSchemas() {
     return this.params.allowedSchemas;
@@ -4272,13 +4387,13 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
   }
   async has(hash) {
     const value = await this.get(hash);
-    if (isAnyPayload4(value)) {
+    if (isAnyPayload6(value)) {
       return this.isAllowed(value);
     }
     return value !== void 0;
   }
   isAllowed(value) {
-    if (isAnyPayload4(value)) {
+    if (isAnyPayload6(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return true;
@@ -4310,26 +4425,26 @@ var SimpleDataLakeRunner = class extends AbstractSimpleDataLake {
   }
   async setMany(entries) {
     const allowed = entries.filter(([_, data]) => this.isAllowed(data));
-    return await this.map.setMany(allowed);
+    await this.map.setMany(allowed);
   }
 };
-__publicField(SimpleDataLakeRunner, "defaultMoniker", DataLakeRunnerMoniker);
+__publicField(SimpleDataLakeRunner, "defaultMoniker", DataLakeRunnerMoniker2);
 __publicField(SimpleDataLakeRunner, "dependencies", []);
-__publicField(SimpleDataLakeRunner, "monikers", [DataLakeRunnerMoniker]);
+__publicField(SimpleDataLakeRunner, "monikers", [DataLakeRunnerMoniker2]);
 SimpleDataLakeRunner = __decorateClass([
   creatableProvider()
 ], SimpleDataLakeRunner);
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
 import {
-  DataLakeViewerMoniker
+  DataLakeViewerMoniker as DataLakeViewerMoniker2
 } from "@xyo-network/xl1-protocol";
 var SimpleDataLakeViewer = class extends AbstractSimpleDataLake {
   moniker = SimpleDataLakeViewer.defaultMoniker;
 };
-__publicField(SimpleDataLakeViewer, "defaultMoniker", DataLakeViewerMoniker);
+__publicField(SimpleDataLakeViewer, "defaultMoniker", DataLakeViewerMoniker2);
 __publicField(SimpleDataLakeViewer, "dependencies", []);
-__publicField(SimpleDataLakeViewer, "monikers", [DataLakeViewerMoniker]);
+__publicField(SimpleDataLakeViewer, "monikers", [DataLakeViewerMoniker2]);
 SimpleDataLakeViewer = __decorateClass([
   creatableProvider()
 ], SimpleDataLakeViewer);
@@ -4365,7 +4480,7 @@ SimpleFinalizationRunner = __decorateClass([
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
 import {
-  assertEx as assertEx36
+  assertEx as assertEx37
 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
@@ -4402,7 +4517,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx36(params.finalizedArchivist, () => "finalizedArchivist is required")
+      finalizedArchivist: assertEx37(params.finalizedArchivist, () => "finalizedArchivist is required")
     };
   }
   async createHandler() {
@@ -4413,13 +4528,13 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async head() {
     return await this.spanAsync("head", async () => {
-      const currentHead = assertEx36(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const currentHead = assertEx37(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         console.log(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx36(block, () => "Could not find current block");
+      return assertEx37(block, () => "Could not find current block");
     }, this.context);
   }
   async headBlock() {
@@ -4445,8 +4560,8 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist;
-    const result = assertEx36(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx36(result?.chain === this.chainId, () => "Chain ID does not match head block chain ID");
+    const result = assertEx37(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx37(result?.chain === this.chainId, () => "Chain ID does not match head block chain ID");
     return result;
   }
 };
@@ -4484,11 +4599,11 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
 import {
-  assertEx as assertEx37,
+  assertEx as assertEx38,
   BigIntToJsonZod,
   isDefined as isDefined19
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder19 } from "@xyo-network/payload-builder";
 import {
   asXL1BlockNumber as asXL1BlockNumber9,
   TransferSchema as TransferSchema3,
@@ -4509,13 +4624,13 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     return this._connection;
   }
   get dataLakes() {
-    throw new Error("Method [dataLakes] not implemented.");
+    return this._dataLakes;
   }
   get signer() {
     return this._signer;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx37(this.connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx38(this.connection.viewer, () => "No viewer available on connection");
     const {
       nbf,
       exp,
@@ -4531,16 +4646,16 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
   async addTransactionToChain(tx) {
     const connection = this.connection;
     const signer = this.signer;
-    const runner = assertEx37(connection.runner, () => "No runner available on connection");
+    const runner = assertEx38(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
-    await this.addPayloadsToDataLakes(signedTx[1]);
+    await this.addPayloadsToDataLakes([...signedTx[1], signedTx[0]]);
     return [await runner.broadcastTransaction(
       [signedTx[0], signedTx[1]]
     ), signedTx];
   }
   async confirmSubmittedTransaction(txHash, options) {
     return await confirmSubmittedTransaction(
-      assertEx37(this.connection.viewer, () => "Connection viewer is undefined"),
+      assertEx38(this.connection.viewer, () => "Connection viewer is undefined"),
       txHash,
       options
     );
@@ -4561,7 +4676,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
         BigIntToJsonZod.parse(amount)
       ])
     );
-    const transfer = new PayloadBuilder18({ schema: TransferSchema3 }).fields({
+    const transfer = new PayloadBuilder19({ schema: TransferSchema3 }).fields({
       from,
       transfers: hexTransfers,
       epoch: Date.now()
@@ -4570,7 +4685,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     return hash;
   }
   async addPayloadsToDataLakes(payloads) {
-    const dataLakes = this._dataLakes?.dataLakes ?? [];
+    const dataLakes = this.dataLakes?.dataLakes ?? [];
     await Promise.all(dataLakes.map(async (dataLake) => {
       await Promise.all(payloads.map(async (payload) => {
         await dataLake?.set(payload._hash, payload);
@@ -4581,10 +4696,10 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
 
 // src/simple/mempool/SimpleMempoolRunner.ts
 import {
-  assertEx as assertEx38,
-  exists as exists5
+  assertEx as assertEx39,
+  exists as exists7
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder19 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/payload-builder";
 import {
   isPayloadBundle
 } from "@xyo-network/payload-model";
@@ -4619,8 +4734,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      pendingBlocksArchivist: assertEx38(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required"),
-      pendingTransactionsArchivist: assertEx38(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
+      pendingBlocksArchivist: assertEx39(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required"),
+      pendingTransactionsArchivist: assertEx39(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
     };
   }
   async createHandler() {
@@ -4654,8 +4769,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
           remainingBlockMap.push(i);
           return b;
         }
-      }).filter(exists5);
-      assertEx38(
+      }).filter(exists7);
+      assertEx39(
         remainingBlockMap.length === remainingBlocks.length,
         () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
       );
@@ -4672,7 +4787,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         if (!valid[i]) {
           return p._hash;
         }
-      }).filter(exists5);
+      }).filter(exists7);
       pruned += pruneHashes.length;
       total += batch.length;
       await this.pendingBlocksArchivist.delete(pruneHashes);
@@ -4692,8 +4807,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   async submitBlocks(blocks) {
     const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
       return hydratedBlockToPayloadBundle([
-        await PayloadBuilder19.addHashMeta(bw),
-        await PayloadBuilder19.addHashMeta(payloads)
+        await PayloadBuilder20.addHashMeta(bw),
+        await PayloadBuilder20.addHashMeta(payloads)
       ]);
     }));
     const inserted = await this.pendingBlocksArchivist.insert(bundles);
@@ -4702,8 +4817,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   async submitTransactions(transactions) {
     const bundles = await Promise.all(transactions.map(async ([tx, payloads]) => {
       return hydratedTransactionToPayloadBundle([
-        await PayloadBuilder19.addHashMeta(tx),
-        await PayloadBuilder19.addHashMeta(payloads)
+        await PayloadBuilder20.addHashMeta(tx),
+        await PayloadBuilder20.addHashMeta(payloads)
       ]);
     }));
     const inserted = await this.pendingTransactionsArchivist.insert(bundles);
@@ -4742,7 +4857,7 @@ SimpleMempoolRunner = __decorateClass([
 
 // src/simple/mempool/SimpleMempoolViewer.ts
 import {
-  exists as exists6,
+  exists as exists8,
   isDefined as isDefined20,
   isHash
 } from "@xylabs/sdk-js";
@@ -4784,7 +4899,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
       cursor
     });
     const filteredBundles = bundles.filter(isPayloadBundle2).filter(isHashMeta2);
-    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists6);
+    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists8);
   }
   async pendingTransactions({ cursor: providedCursor, limit = 100 } = {}) {
     let cursor = void 0;
@@ -4807,7 +4922,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
         const tx = await bundledPayloadToHydratedTransaction(bundle3);
         return isDefined20(tx) ? { bundle: bundle3, tx } : void 0;
       })
-    )).filter(exists6);
+    )).filter(exists8);
     const currentBlock = await this.windowedBlockViewer.currentBlock();
     const evaluated = await Promise.all(
       hydratedWithBundle.map(async ({ bundle: bundle3, tx }) => ({
@@ -4827,7 +4942,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     );
     const inclusionCandidates = (await Promise.all(validTransactions.map((x) => x.tx).map(async (tx) => {
       if (await this.isInclusionCandidate(tx, currentBlock, false)) return tx;
-    }))).filter(exists6);
+    }))).filter(exists8);
     this.logger?.info(`Inclusion candidates: ${inclusionCandidates.length}`);
     return inclusionCandidates;
   }
@@ -4944,7 +5059,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx39 } from "@xylabs/sdk-js";
+import { assertEx as assertEx40 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   invoker;
   _store;
@@ -4953,7 +5068,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx39(this._store, () => "Store must be defined to get permissions");
+    return assertEx40(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -5006,7 +5121,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx40 } from "@xylabs/sdk-js";
+import { assertEx as assertEx41 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   _invoker;
   permissions = [];
@@ -5014,7 +5129,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx40(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx41(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -5027,7 +5142,7 @@ var MemoryPermissionsStore = class {
 };
 
 // src/simple/runner/SimpleXyoRunner.ts
-import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder21 } from "@xyo-network/payload-builder";
 import {
   MempoolRunnerMoniker as MempoolRunnerMoniker2,
   XyoRunnerMoniker
@@ -5040,7 +5155,7 @@ var SimpleXyoRunner = class extends AbstractCreatableProvider {
   }
   async broadcastTransaction(transaction) {
     await this.mempool.submitTransactions([transaction]);
-    const hash = await PayloadBuilder20.hash(transaction[0]);
+    const hash = await PayloadBuilder21.hash(transaction[0]);
     this.logger?.info(`Broadcasted transaction with hash ${hash}`);
     return hash;
   }
@@ -5058,7 +5173,7 @@ SimpleXyoRunner = __decorateClass([
 
 // src/simple/signer/SimpleXyoSigner.ts
 import { Account as Account2 } from "@xyo-network/account";
-import { PayloadBuilder as PayloadBuilder21 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder22 } from "@xyo-network/payload-builder";
 import {
   SignedHydratedTransactionWithHashMetaZod,
   XyoSignerMoniker as XyoSignerMoniker3
@@ -5101,7 +5216,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
   }
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this.params.account);
-    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder21.addStorageMeta(txBW), await PayloadBuilder21.addStorageMeta(tx[1])]);
+    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder22.addStorageMeta(txBW), await PayloadBuilder22.addStorageMeta(tx[1])]);
   }
 };
 
@@ -5188,7 +5303,7 @@ SimpleStakeEventsViewer = __decorateClass([
 // src/simple/timeSync2/SimpleTimeSyncViewer.ts
 import {
   asHash as asHash6,
-  assertEx as assertEx41,
+  assertEx as assertEx42,
   isDefined as isDefined22
 } from "@xylabs/sdk-js";
 import {
@@ -5210,7 +5325,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx41(await this.blockViewer.blockByNumber(asXL1BlockNumber10(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx42(await this.blockViewer.blockByNumber(asXL1BlockNumber10(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
         const timePayload = asTimePayload2(isDefined22(hash) ? payloads.find((p) => p._hash === hash) : void 0);
@@ -5265,10 +5380,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         return [Date.now(), null];
       }
       case "ethereum": {
-        const provider = assertEx41(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx42(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash6(assertEx41(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash6(assertEx42(block?.hash, () => "Block hash not found"), true);
         return [blockNumber, blockHash];
       }
       default: {
@@ -5283,7 +5398,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       // this is for the previous block
       xl1,
       // this is for the previous block
-      xl1Hash: assertEx41(xl1Hash, () => "No xl1 hash available from time sync service"),
+      xl1Hash: assertEx42(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
     if (isDefined22(this.ethProvider)) {
@@ -5304,8 +5419,8 @@ SimpleTimeSyncViewer = __decorateClass([
 
 // src/simple/windowedBlock/SimpleWindowedBlockViewer.ts
 import {
-  assertEx as assertEx42,
-  exists as exists7,
+  assertEx as assertEx43,
+  exists as exists9,
   isNull as isNull2
 } from "@xylabs/sdk-js";
 import {
@@ -5368,14 +5483,14 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     return result;
   }
   blocksByTransactionHashes(hashes) {
-    return hashes.map((hash) => this._transactionHashMap.get(hash)).filter(exists7);
+    return hashes.map((hash) => this._transactionHashMap.get(hash)).filter(exists9);
   }
   chainId(_blockNumber) {
     throw new Error("Method not implemented.");
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = assertEx42(
+    this._blockViewer = assertEx43(
       this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker5),
       () => "BlockViewer instance is required"
     );
@@ -5384,13 +5499,13 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     this._transactionHashMap = new MemoryMap();
   }
   currentBlock() {
-    return assertEx42(this._chain.at(-1));
+    return assertEx43(this._chain.at(-1));
   }
   currentBlockHash() {
-    return assertEx42(this._chain.at(-1)?.[0]._hash);
+    return assertEx43(this._chain.at(-1)?.[0]._hash);
   }
   currentBlockNumber() {
-    return assertEx42(this._chain.at(-1)?.[0].block);
+    return assertEx43(this._chain.at(-1)?.[0].block);
   }
   async payloadByHash(hash) {
     const payloads = await this.payloadsByHash([hash]);
@@ -5549,13 +5664,13 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx43 } from "@xylabs/sdk-js";
+import { assertEx as assertEx44 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context, blockHash);
   const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), { required: true });
-  return assertEx43(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx44(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
@@ -5609,6 +5724,8 @@ export {
   ProviderFactory,
   ProviderFactoryLocator,
   ProviderFactoryLocatorZod,
+  RestDataLakeRunner,
+  RestDataLakeViewer,
   RewardMultipliers,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,