@xyo-network/xl1-protocol-sdk 3.0.3 → 3.0.4

package/dist/neutral/index.mjs

@@ -187,6 +187,74 @@ var XL1Amount = class _XL1Amount {
   }
 };
 
+// src/Archivists/ArchivistFactory.ts
+import { Mutex } from "async-mutex";
+var KEY_SEPARATOR = "::";
+function archivistCacheKey(connectionName, archivistName) {
+  return `${connectionName}${KEY_SEPARATOR}${archivistName}`;
+}
+var ArchivistInstanceCache = class {
+  cache = /* @__PURE__ */ new Map();
+  mutex = new Mutex();
+  async clear() {
+    await this.mutex.runExclusive(() => {
+      this.cache.clear();
+    });
+  }
+  async getOrCreate(connectionName, archivistName, create) {
+    const key = archivistCacheKey(connectionName, archivistName);
+    return await this.mutex.runExclusive(async () => {
+      const existing = this.cache.get(key);
+      if (existing !== void 0) return existing;
+      const created = await create();
+      this.cache.set(key, created);
+      return created;
+    });
+  }
+  has(connectionName, archivistName) {
+    return this.cache.has(archivistCacheKey(connectionName, archivistName));
+  }
+};
+
+// src/Archivists/archivistRoles.ts
+var CHAIN_ARCHIVIST_ROLE = "chain";
+var PENDING_TRANSACTIONS_ARCHIVIST_ROLE = "pending-transactions";
+var PENDING_BLOCKS_ARCHIVIST_ROLE = "pending-blocks";
+var REJECTED_BLOCKS_ARCHIVIST_ROLE = "rejected-blocks";
+var REJECTED_TRANSACTIONS_ARCHIVIST_ROLE = "rejected-transactions";
+
+// src/Archivists/MemoryArchivistFactory.ts
+import { MemoryArchivist } from "@xyo-network/sdk-js";
+var MemoryArchivistFactory = class _MemoryArchivistFactory {
+  static cache = new ArchivistInstanceCache();
+  static async connect(connectionName, _config, options) {
+    const { name, max } = options;
+    return await _MemoryArchivistFactory.cache.getOrCreate(
+      connectionName,
+      name,
+      // Omit `max` when unset so the chain store inherits MemoryArchivist's default
+      // (the node-backed memory fallback never capped it — a small cap would evict blocks).
+      async () => await MemoryArchivist.create({ account: "random", config: max === void 0 ? { name } : { max, name } })
+    );
+  }
+  /** Test-only: drop all cached memory archivists so a fresh process state can be simulated. */
+  static async reset() {
+    await _MemoryArchivistFactory.cache.clear();
+  }
+};
+
+// src/Archivists/connectArchivist.ts
+async function connectArchivist(binding, options) {
+  switch (binding.config.type) {
+    case "memory": {
+      return await MemoryArchivistFactory.connect(binding.name, binding.config, options);
+    }
+    default: {
+      throw new Error(`connectArchivist: connection type '${binding.config.type}' is not self-provisioned \u2014 inject the archivist instead`);
+    }
+  }
+}
+
 // src/block/hydrate/allHashesPresent.ts
 function allHashesPresent(hashes, payloads) {
   const payloadHashes = new Set(payloads.map((p) => p._hash));
@@ -1822,13 +1890,15 @@ var EvmRpcTransportConfigZod = z6.object({
     type: "string"
   })
 }).describe("EVM JSON-RPC transport");
+var MemoryTransportConfigZod = z6.object({ type: z6.literal("memory") }).describe("In-process memory transport");
 var TransportConfigZod = z6.discriminatedUnion("type", [
   LmdbTransportConfigZod,
   MongoTransportConfigZod,
   RpcTransportConfigZod,
   RestTransportConfigZod,
   S3TransportConfigZod,
-  EvmRpcTransportConfigZod
+  EvmRpcTransportConfigZod,
+  MemoryTransportConfigZod
 ]);
 var TransportsConfigZod = z6.record(z6.string(), TransportConfigZod).default({});
 
@@ -4783,7 +4853,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   _headPollTimer = null;
   _signedHydratedBlockCache;
   get finalizedArchivist() {
-    return this.params.finalizedArchivist;
+    return assertEx34(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
   }
   get blocksSummaryMap() {
     this._blocksSummaryMap ??= this.params.blocksSummaryMap ?? new LruCacheMap2({ max: 32 });
@@ -4809,10 +4879,12 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     if (headPollIntervalMs !== void 0) {
       assertEx34(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
     }
+    const connection = params.connection;
+    const finalizedArchivist = params.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
       blocksSummaryMap: params.blocksSummaryMap,
-      finalizedArchivist: assertEx34(params.finalizedArchivist, () => "finalizedArchivist is required"),
+      finalizedArchivist: assertEx34(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection"),
       headPollIntervalMs
     };
   }
@@ -4910,7 +4982,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async createHandler() {
     await super.createHandler();
     this.finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
-    this._store = { chainMap: this.params.finalizedArchivist };
+    this._store = { chainMap: this.finalizedArchivist };
   }
   async currentBlock() {
     return await this.finalizationViewer.head();
@@ -5010,7 +5082,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     this._headPollTimer = null;
   }
 };
-__publicField(SimpleBlockViewer, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleBlockViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
 __publicField(SimpleBlockViewer, "defaultMoniker", BlockViewerMoniker2);
 __publicField(SimpleBlockViewer, "dependencies", [FinalizationViewerMoniker]);
 __publicField(SimpleBlockViewer, "monikers", [BlockViewerMoniker2]);
@@ -5449,16 +5521,28 @@ SimpleDataLakeViewer = __decorateClass([
 ], SimpleDataLakeViewer);
 
 // src/simple/finalization/SimpleFinalizationRunner.ts
+import { assertEx as assertEx38 } from "@xylabs/sdk-js";
 import { FinalizationRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleFinalizationRunner = class extends AbstractCreatableProvider {
   moniker = SimpleFinalizationRunner.defaultMoniker;
   _store;
+  get finalizedArchivist() {
+    return assertEx38(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
+  }
   get store() {
     return this._store;
   }
+  static async paramsHandler(params) {
+    const connection = params?.connection;
+    const finalizedArchivist = params?.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
+    return {
+      ...await super.paramsHandler(params),
+      finalizedArchivist: assertEx38(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
+    };
+  }
   async createHandler() {
     await super.createHandler();
-    this._store = { chainMap: this.params.finalizedArchivist };
+    this._store = { chainMap: this.finalizedArchivist };
   }
   async finalizeBlock(block) {
     const results = await this.finalizeBlocks([block]);
@@ -5471,7 +5555,7 @@ var SimpleFinalizationRunner = class extends AbstractCreatableProvider {
     return sortedBlocks.map((b) => b[0]._hash);
   }
 };
-__publicField(SimpleFinalizationRunner, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleFinalizationRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
 __publicField(SimpleFinalizationRunner, "defaultMoniker", FinalizationRunnerMoniker);
 __publicField(SimpleFinalizationRunner, "dependencies", []);
 __publicField(SimpleFinalizationRunner, "monikers", [FinalizationRunnerMoniker]);
@@ -5481,7 +5565,7 @@ SimpleFinalizationRunner = __decorateClass([
 ], SimpleFinalizationRunner);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import { assertEx as assertEx38 } from "@xylabs/sdk-js";
+import { assertEx as assertEx39 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker3,
@@ -5493,7 +5577,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   _store;
   _signedHydratedBlockCache;
   get finalizedArchivist() {
-    return this.params.finalizedArchivist;
+    return assertEx39(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
   }
   get hydratedBlockCache() {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
@@ -5508,9 +5592,11 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     return this._store;
   }
   static async paramsHandler(params) {
+    const connection = params.connection;
+    const finalizedArchivist = params.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx38(params.finalizedArchivist, () => "finalizedArchivist is required")
+      finalizedArchivist: assertEx39(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
     };
   }
   chainId() {
@@ -5518,19 +5604,20 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    const mostRecentBlock = await findMostRecentBlock(this.params.finalizedArchivist);
-    this._chainId = assertEx38(this.config.chain.id ?? mostRecentBlock?.chain, () => "chain.id is required if empty archivist");
-    this._store = { chainMap: this.params.finalizedArchivist };
+    const finalizedArchivist = this.finalizedArchivist;
+    const mostRecentBlock = await findMostRecentBlock(finalizedArchivist);
+    this._chainId = assertEx39(this.config.chain.id ?? mostRecentBlock?.chain, () => "chain.id is required if empty archivist");
+    this._store = { chainMap: finalizedArchivist };
   }
   async head() {
     return await this.spanAsync("head", async () => {
-      const currentHead = assertEx38(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const currentHead = assertEx39(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         this.logger?.error(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx38(block, () => "Could not find current block");
+      return assertEx39(block, () => "Could not find current block");
     }, this.context);
   }
   async headBlock() {
@@ -5560,12 +5647,12 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist;
-    const result = assertEx38(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx38(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    const result = assertEx39(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx39(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
     return result;
   }
 };
-__publicField(SimpleFinalizationViewer, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleFinalizationViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
 __publicField(SimpleFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker3);
 __publicField(SimpleFinalizationViewer, "dependencies", [ChainContractViewerMoniker3]);
 __publicField(SimpleFinalizationViewer, "monikers", [FinalizationViewerMoniker3]);
@@ -5593,7 +5680,7 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
 import {
-  assertEx as assertEx39,
+  assertEx as assertEx40,
   BigIntToJsonZod,
   isDefined as isDefined20
 } from "@xylabs/sdk-js";
@@ -5626,7 +5713,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     return this._signer;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx39(this.connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx40(this.connection.viewer, () => "No viewer available on connection");
     const {
       nbf,
       exp,
@@ -5642,7 +5729,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
   async addTransactionToChain(tx, offChain = []) {
     const connection = this.connection;
     const signer = this.signer;
-    const runner = assertEx39(connection.runner, () => "No runner available on connection");
+    const runner = assertEx40(connection.runner, () => "No runner available on connection");
     let signedTx;
     if (isSignedHydratedTransaction(tx)) {
       const [bw, payloads] = tx;
@@ -5657,7 +5744,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
   }
   async confirmSubmittedTransaction(txHash, options) {
     return await confirmSubmittedTransaction(
-      assertEx39(this.connection.viewer, () => "Connection viewer is undefined"),
+      assertEx40(this.connection.viewer, () => "Connection viewer is undefined"),
       txHash,
       options
     );
@@ -5696,7 +5783,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
 
 // src/simple/mempool/SimpleMempoolRunner.ts
 import {
-  assertEx as assertEx40,
+  assertEx as assertEx41,
   exists as exists8
 } from "@xylabs/sdk-js";
 import { isPayloadBundle, PayloadBuilder as PayloadBuilder21 } from "@xyo-network/sdk-js";
@@ -5714,7 +5801,7 @@ import {
   TransactionRejectionSchema,
   TransactionValidationViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
-import { Mutex } from "async-mutex";
+import { Mutex as Mutex2 } from "async-mutex";
 var DEFAULT_SYNC_INTERVAL = 3e4;
 var DEFAULT_SYNC_LIMIT = 100;
 var ENFORCE_CAP_BATCH_SIZE = 1e3;
@@ -5731,7 +5818,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   _finalizationViewer;
   _mempoolViewer;
   _transactionValidationViewer;
-  _syncMutex = new Mutex();
+  _syncMutex = new Mutex2();
   _syncTimerId = null;
   get blockValidationViewer() {
     return this._blockValidationViewer;
@@ -5752,10 +5839,10 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     return this.params.maxPendingTransactions ?? 0;
   }
   get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist;
+    return assertEx41(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
   }
   get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist;
+    return assertEx41(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
   }
   get syncInterval() {
     return this.params.syncInterval ?? DEFAULT_SYNC_INTERVAL;
@@ -5770,10 +5857,13 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     return this.params.validateOnSubmit ?? true;
   }
   static async paramsHandler(params) {
+    const connection = params?.connection;
+    const pendingBlocksArchivist = params?.pendingBlocksArchivist ?? (connection ? await connectArchivist(connection, { name: PENDING_BLOCKS_ARCHIVIST_ROLE }) : void 0);
+    const pendingTransactionsArchivist = params?.pendingTransactionsArchivist ?? (connection ? await connectArchivist(connection, { name: PENDING_TRANSACTIONS_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
-      pendingBlocksArchivist: assertEx40(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required"),
-      pendingTransactionsArchivist: assertEx40(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
+      pendingBlocksArchivist: assertEx41(pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection"),
+      pendingTransactionsArchivist: assertEx41(pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection")
     };
   }
   async createHandler() {
@@ -5812,7 +5902,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingBlockMap.push(i);
         return b;
       }).filter(exists8);
-      assertEx40(
+      assertEx41(
         remainingBlockMap.length === remainingBlocks.length,
         () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
       );
@@ -5875,7 +5965,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingTransactionMap.push(i);
         return t;
       }).filter(exists8);
-      assertEx40(
+      assertEx41(
         remainingTransactionMap.length === remainingTransactions.length,
         () => `remainingTransactionMap length should match remainingTransactions length [${remainingTransactionMap.length}/${remainingTransactions.length}]`
       );
@@ -6117,7 +6207,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     this.logger?.debug(`Synced ${externalTxs.length} transactions from external mempool`);
   }
 };
-__publicField(SimpleMempoolRunner, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleMempoolRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
 __publicField(SimpleMempoolRunner, "defaultMoniker", MempoolRunnerMoniker);
 __publicField(SimpleMempoolRunner, "dependencies", [FinalizationViewerMoniker4, BlockValidationViewerMoniker2, TransactionValidationViewerMoniker, ChainContractViewerMoniker4]);
 __publicField(SimpleMempoolRunner, "monikers", [MempoolRunnerMoniker]);
@@ -6128,6 +6218,7 @@ SimpleMempoolRunner = __decorateClass([
 
 // src/simple/mempool/SimpleMempoolViewer.ts
 import {
+  assertEx as assertEx42,
   exists as exists9,
   isDefined as isDefined21,
   isHash as isHash2
@@ -6148,14 +6239,24 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     return this.params.handoutStatsTtlBlocks ?? DEFAULT_HANDOUT_STATS_TTL_BLOCKS;
   }
   get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist;
+    return assertEx42(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
   }
   get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist;
+    return assertEx42(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
   }
   get windowedBlockViewer() {
     return this._windowedBlockViewer;
   }
+  static async paramsHandler(params) {
+    const { connection } = params;
+    const pendingBlocksArchivist = params.pendingBlocksArchivist ?? (connection ? await connectArchivist(connection, { name: PENDING_BLOCKS_ARCHIVIST_ROLE }) : void 0);
+    const pendingTransactionsArchivist = params.pendingTransactionsArchivist ?? (connection ? await connectArchivist(connection, { name: PENDING_TRANSACTIONS_ARCHIVIST_ROLE }) : void 0);
+    return {
+      ...await super.paramsHandler(params),
+      pendingBlocksArchivist,
+      pendingTransactionsArchivist
+    };
+  }
   async createHandler() {
     await super.createHandler();
     this._windowedBlockViewer = await this.locator.getInstance(WindowedBlockViewerMoniker);
@@ -6336,7 +6437,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     return deduplicateWithBundleBySigner(randomSelected).slice(0, effectiveLimit);
   }
 };
-__publicField(SimpleMempoolViewer, "connectionTypes", ["lmdb", "mongo"]);
+__publicField(SimpleMempoolViewer, "connectionTypes", ["lmdb", "mongo", "memory"]);
 __publicField(SimpleMempoolViewer, "defaultMoniker", MempoolViewerMoniker2);
 __publicField(SimpleMempoolViewer, "dependencies", [WindowedBlockViewerMoniker]);
 __publicField(SimpleMempoolViewer, "monikers", [MempoolViewerMoniker2]);
@@ -6427,7 +6528,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx41 } from "@xylabs/sdk-js";
+import { assertEx as assertEx43 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   invoker;
   _store;
@@ -6436,7 +6537,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx41(this._store, () => "Store must be defined to get permissions");
+    return assertEx43(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -6489,7 +6590,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx42 } from "@xylabs/sdk-js";
+import { assertEx as assertEx44 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   _invoker;
   permissions = [];
@@ -6497,7 +6598,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx42(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx44(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -6669,7 +6770,7 @@ SimpleStakeEventsViewer = __decorateClass([
 ], SimpleStakeEventsViewer);
 
 // src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts
-import { assertEx as assertEx43 } from "@xylabs/sdk-js";
+import { assertEx as assertEx45 } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress3 } from "@xyo-network/sdk-js";
 import {
   StakeTotalsViewerMoniker,
@@ -6713,7 +6814,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._stakeViewer = assertEx43(
+    this._stakeViewer = assertEx45(
       await this.locateAndCreate(StakeViewerMoniker),
       () => "Failed to create StakeViewer"
     );
@@ -6769,14 +6870,14 @@ SimpleStakeTotalsViewer = __decorateClass([
 ], SimpleStakeTotalsViewer);
 
 // src/simple/StakeViewer/SimpleStakeViewer.ts
-import { assertEx as assertEx44, toAddress } from "@xylabs/sdk-js";
+import { assertEx as assertEx46, toAddress } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress4 } from "@xyo-network/sdk-js";
 import { StakeEventsViewerMoniker as StakeEventsViewerMoniker2, StakeViewerMoniker as StakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeViewer.defaultMoniker;
   _chainStakeEventsViewer;
   get stakeEvents() {
-    return assertEx44(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx46(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get positions() {
     return this.params.positions;
@@ -6816,7 +6917,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainStakeEventsViewer = assertEx44(
+    this._chainStakeEventsViewer = assertEx46(
       await this.locateAndCreate(StakeEventsViewerMoniker2),
       () => "Failed to create StakeEventsViewer"
     );
@@ -6851,7 +6952,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     return toAddress(toAddress(1n));
   }
   stakeById(id) {
-    return assertEx44(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx46(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
     return this.positions.filter((s) => asXyoAddress4(s.staker) === asXyoAddress4(staker))[slot];
@@ -6955,7 +7056,7 @@ RestSyncViewer = __decorateClass([
 // src/simple/timeSync2/SimpleTimeSyncViewer.ts
 import {
   asHash as asHash5,
-  assertEx as assertEx45,
+  assertEx as assertEx47,
   isDefined as isDefined23
 } from "@xylabs/sdk-js";
 import {
@@ -6977,7 +7078,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx45(await this.blockViewer.blockByNumber(asXL1BlockNumber11(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx47(await this.blockViewer.blockByNumber(asXL1BlockNumber11(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(isDefined23(hash) ? payloads.find((p) => p._hash === hash) : void 0);
@@ -7033,10 +7134,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         return [Date.now(), null];
       }
       case "ethereum": {
-        const provider = assertEx45(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx47(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash5(assertEx45(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash5(assertEx47(block?.hash, () => "Block hash not found"), true);
         return [blockNumber, blockHash];
       }
       default: {
@@ -7051,7 +7152,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       // this is for the previous block
       xl1,
       // this is for the previous block
-      xl1Hash: assertEx45(xl1Hash, () => "No xl1 hash available from time sync service"),
+      xl1Hash: assertEx47(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
     if (isDefined23(this.ethProvider)) {
@@ -7073,7 +7174,7 @@ SimpleTimeSyncViewer = __decorateClass([
 ], SimpleTimeSyncViewer);
 
 // src/simple/transactionValidation/SimpleTransactionValidationViewer.ts
-import { assertEx as assertEx46 } from "@xylabs/sdk-js";
+import { assertEx as assertEx48 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder24 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
@@ -7127,7 +7228,7 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
     let head;
     if (isChainQualifiedHeadConfig6(config)) {
       const headBlockResult = await this.blockViewer.blockByHash(config.head);
-      head = headBlockResult == null ? assertEx46(
+      head = headBlockResult == null ? assertEx48(
         void 0,
         () => `Specified a head that is not in the chain [${config.head}]`
       ) : headBlockResult[0];
@@ -7199,7 +7300,7 @@ SimpleTransactionValidationViewer = __decorateClass([
 ], SimpleTransactionValidationViewer);
 
 // src/simple/TransactionViewer/SimpleTransactionViewer.ts
-import { assertEx as assertEx47, exists as exists10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx49, exists as exists10 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/sdk-js";
 import {
   asSignedHydratedTransactionWithHashMeta,
@@ -7216,7 +7317,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
   async byBlockHashAndIndex(blockHash, transactionIndex) {
     return await this.spanAsync("byBlockHashAndIndex", async () => {
-      assertEx47(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      assertEx49(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
       try {
         const block = await this.blockViewer.blockByHash(blockHash);
         if (!block) return null;
@@ -7281,7 +7382,7 @@ SimpleTransactionViewer = __decorateClass([
 
 // src/simple/windowedBlock/SimpleWindowedBlockViewer.ts
 import {
-  assertEx as assertEx48,
+  assertEx as assertEx50,
   exists as exists11,
   isNull as isNull2
 } from "@xylabs/sdk-js";
@@ -7292,7 +7393,7 @@ import {
   stepSize as stepSize3,
   WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
-import { Mutex as Mutex2 } from "async-mutex";
+import { Mutex as Mutex3 } from "async-mutex";
 var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   moniker = WindowedBlockViewerMoniker2;
   _blockHashMap;
@@ -7300,7 +7401,7 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   // the external BlockViewer
   _blockViewer;
   _chain = [];
-  _syncMutex = new Mutex2();
+  _syncMutex = new Mutex3();
   _timerId = null;
   _transactionHashMap;
   get maxWindowSize() {
@@ -7363,7 +7464,7 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = assertEx48(
+    this._blockViewer = assertEx50(
       this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker7),
       () => "BlockViewer instance is required"
     );
@@ -7372,13 +7473,13 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     this._transactionHashMap = new MemoryMap2();
   }
   currentBlock() {
-    return assertEx48(this._chain.at(-1));
+    return assertEx50(this._chain.at(-1));
   }
   currentBlockHash() {
-    return assertEx48(this._chain.at(-1)?.[0]._hash);
+    return assertEx50(this._chain.at(-1)?.[0]._hash);
   }
   currentBlockNumber() {
-    return assertEx48(this._chain.at(-1)?.[0].block);
+    return assertEx50(this._chain.at(-1)?.[0].block);
   }
   async payloadByHash(hash) {
     const payloads = await this.payloadsByHash([hash]);
@@ -7539,12 +7640,12 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 };
 
 // src/test/buildRandomChain.ts
-import { asAddress as asAddress2, assertEx as assertEx51 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx53 } from "@xylabs/sdk-js";
 import {
   Account as Account4,
   asSchema as asSchema9,
   IdSchema as IdSchema2,
-  MemoryArchivist,
+  MemoryArchivist as MemoryArchivist2,
   PayloadBuilder as PayloadBuilder29
 } from "@xyo-network/sdk-js";
 import {
@@ -7558,7 +7659,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx49, isDefined as isDefined24 } from "@xylabs/sdk-js";
+import { assertEx as assertEx51, isDefined as isDefined24 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload5,
   BoundWitnessBuilder as BoundWitnessBuilder3,
@@ -7641,7 +7742,7 @@ function buildStepHashes(blockNumber, inStepHashes, previousBlockHash, chainStep
         const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
         completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress2, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
-      step_hashes.push(assertEx49(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+      step_hashes.push(assertEx51(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
     } else if (isDefined24(inStepHashes.at(i))) {
       step_hashes.push(inStepHashes[i]);
     }
@@ -7695,7 +7796,7 @@ async function buildBlock(options) {
     protocol
   }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder25.addStorageMeta(payloads));
   const [bw, txPayloads] = await builder.build();
-  assertEx49(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  assertEx51(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
   return [await PayloadBuilder25.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload5(p, true))];
 }
 
@@ -7716,7 +7817,7 @@ async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainS
 }
 
 // src/test/buildRandomGenesisBlock.ts
-import { asAddress, assertEx as assertEx50 } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx52 } from "@xylabs/sdk-js";
 import {
   Account as Account3,
   asAnyPayload as asAnyPayload6,
@@ -7760,7 +7861,7 @@ var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNu
 };
 
 // src/test/buildRandomGenesisBlock.ts
-var TestChainId = assertEx50(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+var TestChainId = assertEx52(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
 
 // src/test/createGenesisBlock.ts
 import { PayloadBuilder as PayloadBuilder28 } from "@xyo-network/sdk-js";
@@ -7815,7 +7916,7 @@ var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genes
 };
 
 // src/test/buildRandomChain.ts
-var TestGenesisBlockRewardAddress = assertEx51(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
+var TestGenesisBlockRewardAddress = assertEx53(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
 var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId, transactionAccount, receiverAddresses) => {
   const chainIdToUse = chainId ?? TestChainId;
   const blocks = [];
@@ -7859,7 +7960,7 @@ var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId,
         receiverAddress
       ));
     }
-    const previousBlock2 = assertEx51(lastBlock?.[0], () => new Error("No last block"));
+    const previousBlock2 = assertEx53(lastBlock?.[0], () => new Error("No last block"));
     const block = await buildNextBlock(previousBlock2, txs, [], [blockProducer], transactionAccountToUse.address);
     blocks.push(block);
     remaining = remaining - 1;
@@ -7870,7 +7971,7 @@ var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId,
 async function buildRandomChainArchivist(count = 20) {
   const producerAccount = await Account4.random();
   const blocks = await buildRandomChain(producerAccount, count);
-  const archivist = await MemoryArchivist.create();
+  const archivist = await MemoryArchivist2.create();
   const payloads = flattenHydratedBlocks(blocks);
   await archivist.insert(payloads);
   return archivist;
@@ -7920,13 +8021,13 @@ function getTestProviderContext2(config) {
 }
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx52 } from "@xylabs/sdk-js";
+import { assertEx as assertEx54 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol-lib";
 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 assertEx52(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx54(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
 // src/validation/lib/isLocalhost.ts
@@ -7979,11 +8080,13 @@ export {
   ActorsConfigZod,
   AddressPairSchema,
   AmbiguousProviderError,
+  ArchivistInstanceCache,
   BalancesStepSummarySchema,
   BaseConfigContextZod,
   BaseConfigZod,
   BoundWitnessHydrator,
   BoundWitnessWithStorageMetaZod,
+  CHAIN_ARCHIVIST_ROLE,
   CHANGE_ADDRESS,
   COIN_TYPES,
   ChainIndexingServiceStateSchema,
@@ -8015,11 +8118,15 @@ export {
   LmdbTransportConfigZod as LmdbConnectionConfigZod,
   LmdbTransportConfigZod,
   LoggerStatusReporter,
+  MemoryArchivistFactory,
   MemoryPermissionsStore,
+  MemoryTransportConfigZod,
   MissingCapabilityError,
   MnemonicStringZod,
   MongoTransportConfigZod as MongoConnectionConfigZod,
   MongoTransportConfigZod,
+  PENDING_BLOCKS_ARCHIVIST_ROLE,
+  PENDING_TRANSACTIONS_ARCHIVIST_ROLE,
   PRODUCER_DIVERSITY_BONUS,
   PayloadLocator,
   PostMessageRpcRemoteConfigZod,
@@ -8030,6 +8137,8 @@ export {
   ProviderFactoryLocator,
   ProviderFactoryLocatorZod,
   ProvidersConfigZod,
+  REJECTED_BLOCKS_ARCHIVIST_ROLE,
+  REJECTED_TRANSACTIONS_ARCHIVIST_ROLE,
   RemoteConfigZod,
   RestTransportConfigZod as RestConnectionConfigZod,
   RestDataLakeConfigZod,
@@ -8103,6 +8212,7 @@ export {
   allHashesPresent,
   allStakersForRange,
   allStakersForStep,
+  archivistCacheKey,
   asActorConfig,
   asActorConfigContext,
   asAddressPairPayload,
@@ -8149,6 +8259,7 @@ export {
   calculateTimeRate,
   chainStepRewardAddress,
   confirmSubmittedTransaction,
+  connectArchivist,
   connectionSubsetBySurface,
   contextCache,
   crackOperation,