@xyo-network/xl1-cli 1.22.0 → 1.23.0

package/dist/cli-min.mjs

@@ -53500,7 +53500,7 @@ function isTransferDescriptor(thing) {
 // src/master/invocation-proxy.ts
 var debugMessages = debug$3("threads:master:messages");
 var nextJobUID = 1;
-var dedupe = (array) => [...new Set(array)];
+var dedupe$1 = (array) => [...new Set(array)];
 var isJobErrorMessage = (data) => data?.type === "error" /* error */;
 var isJobResultMessage = (data) => data?.type === "result" /* result */;
 var isJobStartMessage = (data) => data?.type === "running" /* running */;
@@ -53570,7 +53570,7 @@ function prepareArguments(rawArgs) {
   }
   return {
     args,
-    transferables: transferables.length === 0 ? transferables : dedupe(transferables)
+    transferables: transferables.length === 0 ? transferables : dedupe$1(transferables)
   };
 }
 function createProxyFunction(worker, method) {
@@ -73059,6 +73059,7 @@ UnsignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
 var asSignedTransactionBoundWitness = zodAsFactory(SignedTransactionBoundWitnessZod, "asSignedTransactionBoundWitness");
 var SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod);
+var isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory(SignedTransactionBoundWitnessWithHashMetaZod);
 var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
   SignedTransactionBoundWitnessWithHashMetaZod,
   "asSignedTransactionBoundWitnessWithHashMeta"
@@ -73353,7 +73354,7 @@ var defaultRewardRatio = 0.05;
 var minTransactionFees = {
   base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
   gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
-  gasLimit: AttoXL1(1000000n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(10n * AttoXL1ConvertFactor.nano),
   priority: AttoXL1(0n * AttoXL1ConvertFactor.nano)
 };
 
@@ -73361,7 +73362,7 @@ var minTransactionFees = {
 var defaultTransactionFees = {
   base: minTransactionFees.base,
   gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
-  gasLimit: AttoXL1(1000000n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
   priority: minTransactionFees.priority
 };
 var HydratedTransactionZod = tuple([
@@ -73404,7 +73405,7 @@ tuple([
   WithStorageMetaZod(SignedTransactionBoundWitnessZod),
   array$1(WithStorageMetaZod(PayloadZod).loose())
 ]);
-var CaveatTypesZod = _enum$1(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatTypesZod = _enum$1(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
 var CaveatsZod = object$4({
   type: CaveatTypesZod,
   value: json$3()
@@ -73607,13 +73608,16 @@ var HydratedBlockValidationError = class extends ValidationError {
 };
 ValidationErrorZod.extend({
   chainId: HexZod,
-  name: literal$2("HydratedBlockStateValidationError")
+  name: literal$2("HydratedBlockStateValidationError"),
+  offendingTransactionHashes: array$1(HashZod).optional()
 }).loose();
 var HydratedBlockStateValidationError = class extends ValidationError {
   chainId;
-  constructor(hash, chainId, value, message, cause) {
+  offendingTransactionHashes;
+  constructor(hash, chainId, value, message, cause, offendingTransactionHashes) {
     super(hash, value, message, cause);
     this.chainId = chainId;
+    this.offendingTransactionHashes = offendingTransactionHashes;
   }
 };
 
@@ -74434,7 +74438,7 @@ var RpcRemoteConfigZod = union$1([HttpRpcRemoteConfigZod, PostMessageRpcRemoteCo
 var RemoteConfigZod = object$4({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 var hasMongoConfig = (config) => {
   if (isUndefined(config)) return false;
-  return isDefined(config.connectionString) && isDefined(config.database) && isDefined(config.domain) && isDefined(config.password) && isDefined(config.username);
+  return isDefined(config.connectionString) && isDefined(config.database) && isDefined(config.domain);
 };
 var MongoConfigZod = object$4({
   // TODO: Create from other arguments
@@ -74833,26 +74837,6 @@ async function externalBlockRangeFromStep(context, blockViewer, stepIdentity) {
     return await externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange);
   });
 }
-async function addDataLakePayloadsToPayloads(hashes, payloads, dataLakeViewer) {
-  if (isUndefined(dataLakeViewer)) return [payloads, []];
-  const missingPayloadHashes = hashes.filter((hash) => !payloads.some((p) => p._hash === hash));
-  const payloadsFromDataLake = await PayloadBuilder.addHashMeta(
-    await PayloadBuilder.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload))
-  );
-  return [[...payloads, ...payloadsFromDataLake], payloadsFromDataLake.map((p) => p._hash)];
-}
-
-// src/primitives/datalake/addDataLakePayloads.ts
-async function addDataLakePayloads([boundWitness, payloads], dataLakeViewer) {
-  const [updatedPayloads, foundHashes] = await addDataLakePayloadsToPayloads(boundWitness.payload_hashes, payloads, dataLakeViewer);
-  return [
-    [
-      boundWitness,
-      updatedPayloads
-    ],
-    foundHashes
-  ];
-}
 function mapToMapType(map) {
   return {
     get: (key) => map.get(key),
@@ -75634,6 +75618,7 @@ var registerCreatableProviderFactory = (registry, factory, labels, primary = fal
   const factoryClone = buildProviderFactory(factory, factory.defaultParams, labels);
   registry[factoryClone.defaultMoniker] = [factoryClone, ...registry[factoryClone.defaultMoniker] ?? []];
   for (const moniker of factoryClone.monikers) {
+    if (moniker === factoryClone.defaultMoniker) continue;
     registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...registry[moniker] ?? []] : [...registry[moniker] ?? [], factoryClone];
   }
 };
@@ -76249,10 +76234,9 @@ var MIN_HEAD_POLL_INTERVAL_MS$1 = 5e3;
 var SimpleBlockViewer = class extends AbstractCreatableProvider {
   moniker = SimpleBlockViewer.defaultMoniker;
   _store;
-  dataLakeViewer;
   finalizationViewer;
   payloadCache = new LruCacheMap({ max: 1e4 });
-  signedHydratedBlockWithDataLakePayloadsCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  signedHydratedBlockWithHashMetaCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
   _headPollHash;
   _headPollInProgress = false;
   _headPollTimer = null;
@@ -76288,17 +76272,16 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blockByHash(hash) {
     return await this.spanAsync("blockByHash", async () => {
-      const cachedBlock = this.signedHydratedBlockWithDataLakePayloadsCache.get(hash);
+      const cachedBlock = this.signedHydratedBlockWithHashMetaCache.get(hash);
       if (cachedBlock) {
         return cachedBlock;
       }
       const cache = this.hydratedBlockCache;
       const block = await cache.get(hash);
-      const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []];
-      if (result) {
-        this.signedHydratedBlockWithDataLakePayloadsCache.set(hash, result);
+      if (block) {
+        this.signedHydratedBlockWithHashMetaCache.set(hash, block);
       }
-      return result;
+      return block ?? null;
     }, { ...this.context, timeBudgetLimit: 100 });
   }
   async blockByNumber(blockNumber) {
@@ -76351,13 +76334,11 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this.dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
     this.finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
     this._store = { chainMap: this.params.finalizedArchivist };
   }
   async currentBlock() {
-    const [result] = await addDataLakePayloads(await this.finalizationViewer.head(), this.dataLakeViewer);
-    return result;
+    return await this.finalizationViewer.head();
   }
   async currentBlockHash() {
     return await this.finalizationViewer.headHash();
@@ -76375,7 +76356,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     const cachedHashes = new Set(cachedPayloads.map((p) => p._hash));
     remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
     const finalizedPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
-    const [resultPayloads] = await addDataLakePayloadsToPayloads(hashes, [...cachedPayloads, ...finalizedPayloads.filter(exists$2)], this.dataLakeViewer);
+    const resultPayloads = [...cachedPayloads, ...finalizedPayloads.filter(exists$2)];
     resultPayloads.map((payload) => {
       this.payloadCache.set(payload._hash, payload);
     });
@@ -76414,9 +76395,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     await super.stopHandler();
   }
   async blockByNumberWithContext(chainContext, blockNumber) {
-    const block = asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null;
-    const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []];
-    return result;
+    return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null;
   }
   async pollHead(emitOnChange) {
     if (this._headPollInProgress) return;
@@ -76998,15 +76977,25 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     const [hash] = await this.addPayloadsToChain([transfer], [], options);
     return hash;
   }
+  transactionRequiredGas(hydratedTransaction) {
+    return transactionRequiredGas(hydratedTransaction);
+  }
 };
 var DEFAULT_SYNC_INTERVAL = 3e4;
 var DEFAULT_SYNC_LIMIT = 100;
+var ENFORCE_CAP_BATCH_SIZE = 1e3;
+function isDemotionAware(viewer) {
+  if (!viewer) return false;
+  const candidate = viewer;
+  return typeof candidate.forget === "function" && typeof candidate.getEvictionPriorityOrder === "function";
+}
 var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   moniker = SimpleMempoolRunner.defaultMoniker;
   _blockValidationViewer;
   _chainContractViewer;
   _deadLetterQueueRunner;
   _finalizationViewer;
+  _mempoolViewer;
   _transactionValidationViewer;
   _syncMutex = new Mutex$1();
   _syncTimerId = null;
@@ -77025,6 +77014,9 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   get maxExpAhead() {
     return this.params.maxExpAhead ?? DEFAULT_MAX_EXP_AHEAD;
   }
+  get maxPendingTransactions() {
+    return this.params.maxPendingTransactions ?? 0;
+  }
   get pendingBlocksArchivist() {
     return this.params.pendingBlocksArchivist;
   }
@@ -77040,6 +77032,9 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   get transactionValidationViewer() {
     return this._transactionValidationViewer;
   }
+  get validateOnSubmit() {
+    return this.params.validateOnSubmit ?? true;
+  }
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
@@ -77054,6 +77049,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker);
     this._transactionValidationViewer = await this.locator.getInstance(TransactionValidationViewerMoniker);
     this._deadLetterQueueRunner = await this.locator.tryGetInstance(DeadLetterQueueRunnerMoniker);
+    this._mempoolViewer = await this.locator.tryGetInstance(MempoolViewerMoniker);
   }
   async prunePendingBlocks({
     batchSize = 10,
@@ -77168,6 +77164,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       pruned += pruneHashes.length;
       total += batch.length;
       await this.pendingTransactionsArchivist.delete(pruneHashes);
+      this.forgetBundleHashes(pruneHashes);
       const pruneSet = new Set(pruneHashes);
       const lastSurvivor = batch.findLast((p) => !pruneSet.has(p._hash));
       cursor = lastSurvivor?._sequence ?? cursor;
@@ -77177,8 +77174,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         order: "desc"
       });
     }
-    this.logger?.debug(`prunePendingTransactions completed: pruned=${pruned}, totalChecked=${total}`);
-    return [pruned, total];
+    return this.finalizePruneTransactionsResult(pruned, total);
   }
   async submitBlocks(blocks) {
     const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
@@ -77193,20 +77189,38 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   async submitTransactions(transactions) {
     const headNumber = await this.finalizationViewer.headNumber();
     const maxExp = headNumber + this.maxExpAhead;
-    const validTransactions = transactions.filter(([tx]) => {
+    const expValid = transactions.filter(([tx]) => {
       if (tx.exp > maxExp) {
         this.logger?.debug(`Rejecting transaction with exp ${tx.exp} exceeding max allowed ${maxExp}`);
         return false;
       }
       return true;
     });
-    const bundles = await Promise.all(validTransactions.map(async ([tx, payloads]) => {
-      return hydratedTransactionToPayloadBundle([
+    const hashedTransactions = await Promise.all(
+      expValid.map(async ([tx, payloads]) => [
         await PayloadBuilder.addHashMeta(tx),
         await PayloadBuilder.addHashMeta(payloads)
-      ]);
-    }));
+      ])
+    );
+    if (this.validateOnSubmit) {
+      const validationResults = await Promise.all(
+        hashedTransactions.map(async (tx) => this.transactionValidationViewer.validateTransaction(tx, { value: true, state: true }))
+      );
+      const failures = [];
+      for (const [i, result] of validationResults.entries()) {
+        if (!isSignedHydratedTransactionWithHashMeta(result)) {
+          failures.push({ tx: hashedTransactions[i], errors: result });
+        }
+      }
+      if (failures.length > 0) {
+        await Promise.all(failures.map((f) => this.routeRejectedTransaction(f.tx, f.errors)));
+        const detail = failures.map((f) => `${f.tx[0]._hash}: ${f.errors.map((e) => e.message).join("; ")}`).join(" | ");
+        throw new Error(`SimpleMempoolRunner: rejected ${failures.length} transaction(s) at admission: ${detail}`);
+      }
+    }
+    const bundles = hashedTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
     const inserted = await this.pendingTransactionsArchivist.insert(bundles);
+    await this.enforceCap();
     return inserted.map((p) => p._hash);
   }
   async startHandler() {
@@ -77225,6 +77239,50 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       this._syncTimerId = null;
     }
   }
+  async collectAllPendingTransactionBundles() {
+    const all = [];
+    let cursor;
+    while (true) {
+      const batch = await this.pendingTransactionsArchivist.next({
+        limit: ENFORCE_CAP_BATCH_SIZE,
+        cursor,
+        order: "asc"
+      });
+      if (batch.length === 0) break;
+      all.push(...batch);
+      cursor = batch.at(-1)?._sequence;
+      if (batch.length < ENFORCE_CAP_BATCH_SIZE) break;
+    }
+    return all;
+  }
+  async enforceCap() {
+    const cap = this.maxPendingTransactions;
+    if (cap <= 0) return;
+    const all = await this.collectAllPendingTransactionBundles();
+    if (all.length <= cap) return;
+    const excess = all.length - cap;
+    const bundleHashesOldestFirst = all.map((p) => p._hash);
+    const orderedForEviction = this.orderForEviction(bundleHashesOldestFirst);
+    const toEvict = orderedForEviction.slice(0, excess);
+    await this.pendingTransactionsArchivist.delete(toEvict);
+    this.forgetBundleHashes(toEvict);
+    this.logger?.debug(`enforceCap evicted ${toEvict.length} bundles (pool=${all.length}, cap=${cap})`);
+  }
+  async finalizePruneTransactionsResult(pruned, total) {
+    this.logger?.debug(`prunePendingTransactions completed: pruned=${pruned}, totalChecked=${total}`);
+    await this.enforceCap();
+    return [pruned, total];
+  }
+  forgetBundleHashes(bundleHashes) {
+    if (bundleHashes.length === 0) return;
+    if (isDemotionAware(this._mempoolViewer)) this._mempoolViewer.forget(bundleHashes);
+  }
+  orderForEviction(bundleHashesOldestFirst) {
+    if (isDemotionAware(this._mempoolViewer)) {
+      return this._mempoolViewer.getEvictionPriorityOrder(bundleHashesOldestFirst);
+    }
+    return bundleHashesOldestFirst;
+  }
   async routeRejectedTransaction(transaction, errors) {
     if (!this._deadLetterQueueRunner) return;
     const rejectionErrors = errors.map((e) => ({
@@ -77329,9 +77387,18 @@ SimpleMempoolRunner = __decorateClass$4([
   creatableProvider()
 ], SimpleMempoolRunner);
 var DEFAULT_MEMPOOL_SELECTION_RATIO = 0.66;
+var DEFAULT_DEMOTION_THRESHOLD = 3;
+var DEFAULT_HANDOUT_STATS_TTL_BLOCKS = 1e3;
 var SimpleMempoolViewer = class extends AbstractCreatableProvider {
   moniker = SimpleMempoolViewer.defaultMoniker;
+  _handoutStats = /* @__PURE__ */ new Map();
   _windowedBlockViewer;
+  get demotionThreshold() {
+    return this.params.demotionThreshold ?? DEFAULT_DEMOTION_THRESHOLD;
+  }
+  get handoutStatsTtlBlocks() {
+    return this.params.handoutStatsTtlBlocks ?? DEFAULT_HANDOUT_STATS_TTL_BLOCKS;
+  }
   get pendingBlocksArchivist() {
     return this.params.pendingBlocksArchivist;
   }
@@ -77345,6 +77412,32 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     await super.createHandler();
     this._windowedBlockViewer = await this.locator.getInstance(WindowedBlockViewerMoniker);
   }
+  /** Drop handout stats for the given bundle hashes. Called when a bundle has been evicted or otherwise removed from the pool. */
+  forget(bundleHashes) {
+    for (const hash of bundleHashes) this._handoutStats.delete(hash);
+  }
+  /** Return the subset of the given bundle hashes that are currently considered demoted. */
+  getDemotedBundleHashes(bundleHashes) {
+    return bundleHashes.filter((hash) => this.isDemoted(hash));
+  }
+  /**
+   * Return the bundle hashes in the order they should be evicted under size pressure.
+   * Demoted entries come first, sorted by handouts descending; the remainder is left as-is
+   * so the caller can append by FIFO sequence order.
+   */
+  getEvictionPriorityOrder(bundleHashes) {
+    const demoted = [];
+    const nonDemoted = [];
+    for (const hash of bundleHashes) {
+      if (this.isDemoted(hash)) demoted.push(hash);
+      else nonDemoted.push(hash);
+    }
+    demoted.sort((a, b) => (this._handoutStats.get(b)?.handouts ?? 0) - (this._handoutStats.get(a)?.handouts ?? 0));
+    return [...demoted, ...nonDemoted];
+  }
+  getHandoutStats(bundleHash) {
+    return this._handoutStats.get(bundleHash);
+  }
   async pendingBlocks({ cursor: providedCursor } = {}) {
     let cursor = void 0;
     if (isHash(providedCursor)) {
@@ -77387,6 +77480,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
       })
     )).filter(exists$2);
     const currentBlock = await this.windowedBlockViewer.currentBlock();
+    const currentBlockNumber = currentBlock[0].block;
     const evaluated = await Promise.all(
       hydratedWithBundle.map(async ({ bundle: bundle3, tx }) => ({
         bundle: bundle3,
@@ -77400,25 +77494,43 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     await Promise.all(
       deletionCandidates.map(async ({ bundle: bundle3, tx }) => {
         await this.deleteBundledTransaction(bundle3);
+        this._handoutStats.delete(bundle3._hash);
         this.logger?.debug(`Purged completed/expired bundled transaction: ${bundle3._hash}/${tx[0]._hash}`);
       })
     );
-    const inclusionCandidates = (await Promise.all(validTransactions.map((x) => x.tx).map(async (tx) => {
-      if (await this.isInclusionCandidate(tx, currentBlock, false)) return tx;
+    this.gcHandoutStats(currentBlockNumber);
+    const inclusionCandidates = (await Promise.all(validTransactions.map(async ({ bundle: bundle3, tx }) => {
+      if (await this.isInclusionCandidate(tx, currentBlock, false)) return { bundle: bundle3, tx };
     }))).filter(exists$2);
     const selectionRatio = this.params.mempoolSelectionRatio ?? DEFAULT_MEMPOOL_SELECTION_RATIO;
-    const maxByRatio = Math.ceil(inclusionCandidates.length * selectionRatio);
-    const effectiveLimit = Math.min(limit, maxByRatio);
-    const randomInclusionCandidates = deduplicateBySigner(
-      inclusionCandidates.filter(() => Math.random() < selectionRatio)
-    ).slice(0, effectiveLimit);
-    const result = randomInclusionCandidates.length > 0 ? randomInclusionCandidates : deduplicateBySigner(inclusionCandidates).slice(0, 1);
-    this.logger?.debug(`Inclusion candidates: ${inclusionCandidates.length}`);
-    return result;
+    const nonDemoted = inclusionCandidates.filter(({ bundle: bundle3 }) => !this.isDemoted(bundle3._hash));
+    const demoted = inclusionCandidates.filter(({ bundle: bundle3 }) => this.isDemoted(bundle3._hash));
+    const primary = this.selectWithRatio(nonDemoted, limit, selectionRatio);
+    const topupNeeded = limit - primary.length;
+    const topup = topupNeeded > 0 ? this.selectWithRatio(demoted, topupNeeded, selectionRatio) : [];
+    let combined = [...primary, ...topup];
+    if (combined.length === 0 && inclusionCandidates.length > 0) {
+      combined = deduplicateWithBundleBySigner(inclusionCandidates).slice(0, 1);
+    }
+    for (const { bundle: bundle3 } of combined) {
+      this.recordHandout(bundle3._hash, currentBlockNumber);
+    }
+    this.logger?.debug(`Inclusion candidates: ${inclusionCandidates.length} (nonDemoted=${nonDemoted.length}, demoted=${demoted.length}); returning ${combined.length}`);
+    return combined.map(({ tx }) => tx);
+  }
+  isDemoted(bundleHash) {
+    const stats = this._handoutStats.get(bundleHash);
+    return stats !== void 0 && stats.handouts >= this.demotionThreshold;
   }
   async deleteBundledTransaction(bundle3) {
     await this.pendingTransactionsArchivist.delete([bundle3._hash]);
   }
+  gcHandoutStats(currentBlockNumber) {
+    const ttl = this.handoutStatsTtlBlocks;
+    for (const [hash, stats] of this._handoutStats) {
+      if (currentBlockNumber - stats.firstHandoutAt > ttl) this._handoutStats.delete(hash);
+    }
+  }
   /**
    * Evaluates a transaction to determine if it should be purged from the mempool.
    * @param tx The transaction to evaluate
@@ -77451,6 +77563,21 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     if (checkForDeletable && await this.isDeletable(tx, currentBlock)) return false;
     return true;
   }
+  recordHandout(bundleHash, currentBlockNumber) {
+    const existing = this._handoutStats.get(bundleHash);
+    if (existing) {
+      existing.handouts += 1;
+    } else {
+      this._handoutStats.set(bundleHash, { handouts: 1, firstHandoutAt: currentBlockNumber });
+    }
+  }
+  selectWithRatio(group, take, selectionRatio) {
+    if (take <= 0 || group.length === 0) return [];
+    const maxByRatio = Math.ceil(group.length * selectionRatio);
+    const effectiveLimit = Math.min(take, maxByRatio);
+    const randomSelected = group.filter(() => Math.random() < selectionRatio);
+    return deduplicateWithBundleBySigner(randomSelected).slice(0, effectiveLimit);
+  }
 };
 __publicField$4(SimpleMempoolViewer, "defaultMoniker", MempoolViewerMoniker);
 __publicField$4(SimpleMempoolViewer, "dependencies", [WindowedBlockViewerMoniker]);
@@ -77458,9 +77585,9 @@ __publicField$4(SimpleMempoolViewer, "monikers", [MempoolViewerMoniker]);
 SimpleMempoolViewer = __decorateClass$4([
   creatableProvider()
 ], SimpleMempoolViewer);
-function deduplicateBySigner(txs) {
+function deduplicateWithBundleBySigner(items) {
   const seen = /* @__PURE__ */ new Set();
-  return txs.filter((tx) => {
+  return items.filter(({ tx }) => {
     const key = tx[0].addresses.toSorted().join(",");
     if (seen.has(key)) return false;
     seen.add(key);
@@ -79567,7 +79694,7 @@ function requireRe () {
 		createToken('GTLT', '((?:<|>)?=?)');
 
 		// Something like "2.*" or "1.2.x".
-		// Note that "x.x" is a valid xRange identifer, meaning "any version"
+		// Note that "x.x" is a valid xRange identifier, meaning "any version"
 		// Only the first item is strictly required.
 		createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
 		createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
@@ -80563,6 +80690,62 @@ function requireCoerce () {
 	return coerce_1;
 }
 
+var truncate_1;
+var hasRequiredTruncate;
+
+function requireTruncate () {
+	if (hasRequiredTruncate) return truncate_1;
+	hasRequiredTruncate = 1;
+
+	const parse = requireParse$1();
+	const constants = requireConstants();
+	const SemVer = requireSemver$1();
+
+	const truncate = (version, truncation, options) => {
+	  if (!constants.RELEASE_TYPES.includes(truncation)) {
+	    return null
+	  }
+
+	  const clonedVersion = cloneInputVersion(version, options);
+	  return clonedVersion && doTruncation(clonedVersion, truncation)
+	};
+
+	const cloneInputVersion = (version, options) => {
+	  const versionStringToParse = (
+	    version instanceof SemVer ? version.version : version
+	  );
+
+	  return parse(versionStringToParse, options)
+	};
+
+	const doTruncation = (version, truncation) => {
+	  if (isPrerelease(truncation)) {
+	    return version.version
+	  }
+
+	  version.prerelease = [];
+
+	  switch (truncation) {
+	    case 'major':
+	      version.minor = 0;
+	      version.patch = 0;
+	      break
+	    case 'minor':
+	      version.patch = 0;
+	      break
+	  }
+
+	  return version.format()
+	};
+
+	const isPrerelease = (type) => {
+	  return type.startsWith('pre')
+	};
+
+	truncate_1 = truncate;
+	return truncate_1;
+}
+
 var lrucache;
 var hasRequiredLrucache;
 
@@ -82012,6 +82195,7 @@ function requireSemver () {
 	const lte = requireLte();
 	const cmp = requireCmp();
 	const coerce = requireCoerce();
+	const truncate = requireTruncate();
 	const Comparator = requireComparator();
 	const Range = requireRange$1();
 	const satisfies = requireSatisfies();
@@ -82050,6 +82234,7 @@ function requireSemver () {
 	  lte,
 	  cmp,
 	  coerce,
+	  truncate,
 	  Comparator,
 	  Range,
 	  satisfies,
@@ -85149,38 +85334,29 @@ JsonRpcAccountBalanceViewer = __decorateClass$3([
 ], JsonRpcAccountBalanceViewer);
 var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
   moniker = BlockViewerMoniker;
-  dataLakeViewer;
   async blocksByHash(hash, limit) {
-    const result = await this.transport.sendRequest(
+    return await this.transport.sendRequest(
       "blockViewer_blocksByHash",
       isDefined(limit) ? [hash, limit] : [hash]
     );
-    return await Promise.all(result.map(async (block) => (await addDataLakePayloads(block, this.dataLakeViewer))[0]));
   }
   async blocksByNumber(block, limit) {
-    const result = await this.transport.sendRequest(
+    return await this.transport.sendRequest(
       "blockViewer_blocksByNumber",
       isDefined(limit) ? [block, limit] : [block]
     );
-    return await Promise.all(result.map(async (block2) => (await addDataLakePayloads(block2, this.dataLakeViewer))[0]));
-  }
-  async createHandler() {
-    await super.createHandler();
-    this.dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
   }
   async currentBlock() {
-    const result = await this.transport.sendRequest(
+    return await this.transport.sendRequest(
       "blockViewer_currentBlock",
       []
     );
-    return (await addDataLakePayloads(result, this.dataLakeViewer))[0];
   }
   async payloadsByHash(hashes) {
-    const result = await this.transport.sendRequest(
+    return await this.transport.sendRequest(
       "blockViewer_payloadsByHash",
       [hashes]
     );
-    return (await addDataLakePayloadsToPayloads(hashes, result, this.dataLakeViewer))[0];
   }
   schemas() {
     return BlockViewerRpcSchemas;
@@ -85530,7 +85706,6 @@ JsonRpcTimeSyncViewer = __decorateClass$3([
 ], JsonRpcTimeSyncViewer);
 var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
   moniker = JsonRpcTransactionViewer.defaultMoniker;
-  dataLakeViewer;
   _blockViewer;
   get blockViewer() {
     return this._blockViewer;
@@ -85566,24 +85741,23 @@ var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
   }
   async byHash(transactionHash) {
     const result = await this.transport.sendRequest("transactionViewer_byHash", [transactionHash]);
-    return result ? (await addDataLakePayloads(result, this.dataLakeViewer))[0] : null;
+    return result ?? null;
   }
   async createHandler() {
     await super.createHandler();
     this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
-    this.dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
   }
   async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
     const result = await this.transport.sendRequest("transactionViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
-    return result ? (await addDataLakePayloads(result, this.dataLakeViewer))[0] : null;
+    return result ?? null;
   }
   async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
     const result = await this.transport.sendRequest("transactionViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
-    return result ? (await addDataLakePayloads(result, this.dataLakeViewer))[0] : null;
+    return result ?? null;
   }
   async transactionByHash(transactionHash) {
     const result = await this.transport.sendRequest("transactionViewer_transactionByHash", [transactionHash]);
-    return result ? (await addDataLakePayloads(result, this.dataLakeViewer))[0] : null;
+    return result ?? null;
   }
   schemas() {
     return TransactionViewerRpcSchemas;
@@ -111901,6 +112075,16 @@ var validateHydratedBlock = /* @__PURE__ */ __name$g(async (context, hydratedBlo
   }
   return errors;
 }, "validateHydratedBlock");
+function offendingTransactionHashesForAddress(block, address) {
+  const hashes = [];
+  for (const payload of block[1]) {
+    if (isSignedTransactionBoundWitnessWithHashMeta(payload) && payload.from === address) {
+      hashes.push(payload._hash);
+    }
+  }
+  return hashes;
+}
+__name$g(offendingTransactionHashesForAddress, "offendingTransactionHashesForAddress");
 var RequiredBalanceBlockStateValidator = /* @__PURE__ */ __name$g(async (context, block) => {
   return await spanRootAsync("RequiredBalanceBlockStateValidator", async () => {
     const errors = [];
@@ -111930,7 +112114,8 @@ var RequiredBalanceBlockStateValidator = /* @__PURE__ */ __name$g(async (context
           });
           const balance = result[address] ?? AttoXL1(0n);
           if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
-            errors.push(new HydratedBlockStateValidationError(block?.[0]?._hash ?? ZERO_HASH, chainId, block, `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`));
+            const offendingTransactionHashes = offendingTransactionHashesForAddress(block, address);
+            errors.push(new HydratedBlockStateValidationError(block?.[0]?._hash ?? ZERO_HASH, chainId, block, `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`, void 0, offendingTransactionHashes.length > 0 ? offendingTransactionHashes : void 0));
           }
         }
       }, context);
@@ -111963,6 +112148,24 @@ var validateHydratedBlockState = /* @__PURE__ */ __name$g(async (context, hydrat
     return errors;
   }, context);
 }, "validateHydratedBlockState");
+async function balanceShortfallErrors(context, tx, requiredBalances) {
+  const errors = [];
+  const requiredAddresses = Object.keys(requiredBalances);
+  if (requiredAddresses.length === 0) return errors;
+  const headBlock = (await context.blockViewer.currentBlock())[0];
+  const balances = await context.accountBalanceViewer.accountBalances(requiredAddresses, {
+    head: headBlock._hash
+  });
+  for (const address of requiredAddresses) {
+    const reqBalance = requiredBalances[address];
+    const balance = balances[address] ?? AttoXL1(0n);
+    if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
+      errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, `insufficient balance for ${address} ${balance} < ${reqBalance}`));
+    }
+  }
+  return errors;
+}
+__name$g(balanceShortfallErrors, "balanceShortfallErrors");
 var RequiredBalanceTransactionStateValidator = /* @__PURE__ */ __name$g(async (context, tx) => {
   return await spanRootAsync("RequiredBalanceTransactionStateValidator", async () => {
     const errors = [];
@@ -111972,26 +112175,18 @@ var RequiredBalanceTransactionStateValidator = /* @__PURE__ */ __name$g(async (c
       }, tx[1]);
       const wrapper = await HydratedTransactionWrapper.parse(tx);
       const from = wrapper.boundWitness.from;
-      const gasCost = transactionRequiredGas(tx) * wrapper.fees.gasPrice;
+      const gasRequired = transactionRequiredGas(tx);
+      if (wrapper.fees.gasLimit < gasRequired) {
+        errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, `fees.gasLimit ${wrapper.fees.gasLimit} < required gas ${gasRequired}`));
+      }
+      const gasCost = gasRequired * wrapper.fees.gasPrice;
       const baseCost = wrapper.fees.base;
       netBalances[from] = (netBalances[from] ?? 0n) - gasCost - baseCost;
       const requiredBalances = {};
       for (const [address, net] of Object.entries(netBalances)) {
         if (net < 0n) requiredBalances[address] = -net;
       }
-      const requiredAddresses = Object.keys(requiredBalances);
-      if (requiredAddresses.length === 0) return errors;
-      const headBlock = (await context.blockViewer.currentBlock())[0];
-      const balances = await context.accountBalanceViewer.accountBalances(requiredAddresses, {
-        head: headBlock._hash
-      });
-      for (const address of requiredAddresses) {
-        const reqBalance = requiredBalances[address];
-        const balance = balances[address] ?? AttoXL1(0n);
-        if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
-          errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, `insufficient balance for ${address} ${balance} < ${reqBalance}`));
-        }
-      }
+      errors.push(...await balanceShortfallErrors(context, tx, requiredBalances));
     } catch (ex) {
       errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, `Failed RequiredBalanceTransactionStateValidator: ${ex}`, ex));
     }
@@ -113615,6 +113810,70 @@ async function generateTransactionFeeTransfers(address, transactions) {
   return payloads;
 }
 __name$d(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
+async function scoreTransaction(tx) {
+  const wrapper = await HydratedTransactionWrapper.parse(tx);
+  const from = wrapper.boundWitness.from;
+  const gasPrice = wrapper.fees.gasPrice;
+  const gasCost = transactionRequiredGas(tx) * gasPrice;
+  const baseCost = wrapper.fees.base;
+  const netBalances = netBalancesForPayloads({
+    }, tx[1]);
+  const fromNet = netBalances[from] ?? 0n;
+  const transferOut = fromNet < 0n ? -fromNet : 0n;
+  return {
+    cost: gasCost + baseCost + transferOut,
+    gasPrice
+  };
+}
+__name$d(scoreTransaction, "scoreTransaction");
+async function identifyOffendingTransactions(args) {
+  const { errors, candidateTransactions } = args;
+  const candidateHashes = new Set(candidateTransactions.map((tx) => tx[0]._hash));
+  const txInvalidHashes = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    if (candidateHashes.has(error.hash)) txInvalidHashes.add(error.hash);
+    const cause = error.cause;
+    if (cause?.hash && candidateHashes.has(cause.hash)) txInvalidHashes.add(cause.hash);
+  }
+  if (txInvalidHashes.size > 0) {
+    return {
+      offendingHashes: [
+        ...txInvalidHashes
+      ],
+      reason: "tx-invalid"
+    };
+  }
+  const balanceOffenderHashes = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    const offendingHashes = error.offendingTransactionHashes ?? [];
+    for (const hash of offendingHashes) {
+      if (candidateHashes.has(hash)) balanceOffenderHashes.add(hash);
+    }
+  }
+  if (balanceOffenderHashes.size === 0) {
+    return {
+      offendingHashes: [],
+      reason: "unknown"
+    };
+  }
+  const offenders = candidateTransactions.filter((tx) => balanceOffenderHashes.has(tx[0]._hash));
+  const scored = await Promise.all(offenders.map(async (tx) => ({
+    tx,
+    ...await scoreTransaction(tx)
+  })));
+  scored.sort((a, b) => {
+    if (a.cost !== b.cost) return a.cost < b.cost ? 1 : -1;
+    if (a.gasPrice !== b.gasPrice) return a.gasPrice < b.gasPrice ? -1 : 1;
+    return a.tx[0]._hash < b.tx[0]._hash ? -1 : 1;
+  });
+  return {
+    offendingHashes: [
+      scored[0].tx[0]._hash
+    ],
+    reason: "block-balance"
+  };
+}
+__name$d(identifyOffendingTransactions, "identifyOffendingTransactions");
 
 // src/simple/block/runner/SimpleBlockRunner.ts
 function _ts_decorate4(decorators, target, key, desc) {
@@ -113647,6 +113906,9 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   moniker = _SimpleBlockRunner.defaultMoniker;
   _blockRewardDiviner;
   _deadLetterQueueRunner;
+  // TODO(producer-exclusion-set): uncapped for v1. If memory grows in long-running producers,
+  // add FIFO eviction or a TTL keyed off block number.
+  _excludedTransactionHashes = /* @__PURE__ */ new Set();
   _lastRedeclarationBlock;
   _rejectedTransactionsArchivist;
   _account;
@@ -113788,17 +114050,18 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         const { block: previousBlock } = assertEx(asBlockBoundWitness(head), () => "Invalid head block");
         const nextBlock = previousBlock + 1;
         const chainId = await this.finalizationViewer.chainId();
-        const pendingTransactions = await this.mempoolViewer.pendingTransactions({
+        const pendingTransactionsRaw = await this.mempoolViewer.pendingTransactions({
           limit: _SimpleBlockRunner.DefaultBlockSize
         });
+        const pendingTransactions = pendingTransactionsRaw.filter((tx) => !this._excludedTransactionHashes.has(tx[0]._hash));
         const nextBlockTransactions = await this.rejectWrongChainTransactions(pendingTransactions, chainId);
         this.logger?.log(`Pending Tx Count ${nextBlockTransactions.length}`);
-        const blockPayloads = [];
+        const nonTxPayloads = [];
         const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
-        if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload);
+        if (producerRedeclarationPayload) nonTxPayloads.push(producerRedeclarationPayload);
         if (nextBlockTransactions.length === 0 && !this.heartbeatRequired(head) && !force) return;
         const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock);
-        blockPayloads.push(...rewardTransferPayloads);
+        nonTxPayloads.push(...rewardTransferPayloads);
         const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions);
         const timeStart = Date.now();
         const timePayload = await this.generateTimePayload();
@@ -113806,48 +114069,26 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         if (timeDuration > 100) {
           this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`);
         }
-        const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances);
-        blockPayloads.push(...fundedTransfers, timePayload);
-        this.logger?.info(`Building block ${head.block + 1}`);
-        const startBuild = Date.now();
+        const [initialFundedTransactions, initialFundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances);
         const stepRewardPoolBalance = (await this.accountBalanceViewer.accountBalances([
           XYO_STEP_REWARD_ADDRESS
         ]))[XYO_STEP_REWARD_ADDRESS];
-        const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
-          this.account
-        ], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance, void 0, chainId);
-        this.logger?.info(`Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`);
-        this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`);
-        const startValidate = Date.now();
-        const validatedBlock = await this.blockValidationViewer.validateBlock(block, {
-          head: head._hash
+        const result = await this.runBuildValidateRetryLoop({
+          head,
+          chainId,
+          stepRewardPoolBalance,
+          nonTxPayloads,
+          timePayload,
+          initialFundedTransactions,
+          initialFundedTransfers
         });
-        this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`);
-        if (isSignedHydratedBlockWithHashMeta(validatedBlock)) {
+        if (isSignedHydratedBlockWithHashMeta(result.block)) {
           await this.mempoolRunner.submitBlocks([
-            validatedBlock
+            result.block
           ]);
-          return validatedBlock;
-        } else {
-          const errors = validatedBlock;
-          this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
-          if (this._deadLetterQueueRunner) {
-            const rejectionErrors = errors.map((e) => ({
-              hash: block[0]._hash,
-              name: "BlockValidationError",
-              message: String(e.message ?? e)
-            }));
-            await this._deadLetterQueueRunner.rejectBlock({
-              schema: BlockRejectionSchema,
-              block,
-              errors: rejectionErrors,
-              rejector: "producer"
-            });
-          } else {
-            const rejectedTransactions = block[1];
-            await this.rejectedTransactionsArchivist.insert(rejectedTransactions);
-          }
+          return result.block;
         }
+        if (result.block) await this.rejectExhaustedBlock(result.block, result.errors);
       } catch (error) {
         this.logger?.error(`Error proposing next valid block: ${error.message}`);
         throw error;
@@ -113894,6 +114135,24 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
     }
     return false;
   }
+  async rejectExhaustedBlock(block, errors) {
+    this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`);
+    if (this._deadLetterQueueRunner) {
+      const rejectionErrors = errors.map((e) => ({
+        hash: block[0]._hash,
+        name: "BlockValidationError",
+        message: String(e.message ?? e)
+      }));
+      await this._deadLetterQueueRunner.rejectBlock({
+        schema: BlockRejectionSchema,
+        block,
+        errors: rejectionErrors,
+        rejector: "producer"
+      });
+    } else {
+      await this.rejectedTransactionsArchivist.insert(block[1]);
+    }
+  }
   // Partition pending transactions by chain-ID match; route mismatches to the transaction DLQ.
   async rejectWrongChainTransactions(transactions, chainId) {
     const localChain = chainId.toLowerCase();
@@ -113924,6 +114183,51 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
     }
     return matched;
   }
+  async runBuildValidateRetryLoop(args) {
+    const { chainId, head, initialFundedTransactions, initialFundedTransfers, nonTxPayloads, stepRewardPoolBalance, timePayload } = args;
+    const maxAttempts = Math.max(1, initialFundedTransactions.length);
+    let candidateTransactions = initialFundedTransactions;
+    let candidateTransfers = initialFundedTransfers;
+    let lastBlock;
+    let lastErrors = [];
+    for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+      const blockPayloads = [
+        ...nonTxPayloads,
+        ...candidateTransfers,
+        timePayload
+      ];
+      this.logger?.info(`Building block ${head.block + 1}${attempt > 0 ? ` (retry ${attempt})` : ""}`);
+      lastBlock = await buildNextBlock(head, candidateTransactions, blockPayloads, [
+        this.account
+      ], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance, void 0, chainId);
+      const validated = await this.blockValidationViewer.validateBlock(lastBlock, {
+        head: head._hash
+      });
+      if (isSignedHydratedBlockWithHashMeta(validated)) {
+        return {
+          block: validated,
+          errors: []
+        };
+      }
+      lastErrors = validated;
+      if (attempt === maxAttempts) break;
+      const { offendingHashes, reason } = await identifyOffendingTransactions({
+        candidateTransactions,
+        errors: validated
+      });
+      if (offendingHashes.length === 0 || reason === "unknown") break;
+      for (const offendingHash of offendingHashes) this._excludedTransactionHashes.add(offendingHash);
+      const offendingSet = new Set(offendingHashes);
+      candidateTransactions = candidateTransactions.filter((tx) => !offendingSet.has(tx[0]._hash));
+      const remainingFromAddresses = new Set(candidateTransactions.map((tx) => tx[0].from));
+      candidateTransfers = (await generateTransactionFeeTransfers(this.address, candidateTransactions)).filter((t) => remainingFromAddresses.has(t.from));
+      this.logger?.warn(`Block validation failed (attempt ${attempt + 1}); excluded ${offendingHashes.length} tx(s), retrying`);
+    }
+    return {
+      block: lastBlock,
+      errors: lastErrors
+    };
+  }
 };
 SimpleBlockRunner = _ts_decorate4([
   creatableProvider()
@@ -185742,6 +186046,8 @@ BaseConfigContextZod.extend({
 });
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
+var DEFAULT_MEMPOOL_DEMOTION_THRESHOLD = 3;
+var DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS = 0;
 var MempoolConfigZod = HostActorConfigZod.extend({
   enabled: union$1([
     string$2(),
@@ -185778,6 +186084,16 @@ var MempoolConfigZod = HostActorConfigZod.extend({
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
+  demotionThreshold: number$2().int().positive().default(DEFAULT_MEMPOOL_DEMOTION_THRESHOLD).register(globalRegistry, {
+    description: "Number of times a transaction may be handed out to producers without being included in a block before it is considered demoted",
+    title: "mempool.demotionThreshold",
+    type: "number"
+  }),
+  maxPendingTransactions: number$2().int().nonnegative().default(DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS).register(globalRegistry, {
+    description: "Maximum number of pending transactions in the pool. When exceeded, demoted transactions are evicted first, then oldest by sequence. 0 disables the cap.",
+    title: "mempool.maxPendingTransactions",
+    type: "number"
+  }),
   transactionPruneInterval: number$2().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
@@ -186543,6 +186859,14 @@ function createDefaultCapabilityRegistry() {
   return registry;
 }
 __name$8(createDefaultCapabilityRegistry, "createDefaultCapabilityRegistry");
+function readMempoolTuning(ctx) {
+  const cfg = ctx.actorContext.config;
+  return {
+    demotionThreshold: cfg?.mempool?.demotionThreshold,
+    maxPendingTransactions: cfg?.mempool?.maxPendingTransactions
+  };
+}
+__name$8(readMempoolTuning, "readMempoolTuning");
 var passes = /* @__PURE__ */ __name$8(() => true, "passes");
 var localTier1Descriptors = [
   {
@@ -186559,10 +186883,14 @@ var localTier1Descriptors = [
     ],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name$8((ctx) => SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
-    }), "build")
+    build: /* @__PURE__ */ __name$8((ctx) => {
+      const { demotionThreshold } = readMempoolTuning(ctx);
+      return SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
+        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+        demotionThreshold
+      });
+    }, "build")
   },
   {
     id: "SimpleMempoolRunner",
@@ -186578,10 +186906,14 @@ var localTier1Descriptors = [
     ],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name$8((ctx) => SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
-    }), "build")
+    build: /* @__PURE__ */ __name$8((ctx) => {
+      const { maxPendingTransactions } = readMempoolTuning(ctx);
+      return SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
+        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+        maxPendingTransactions
+      });
+    }, "build")
   },
   {
     id: "SimpleAccountBalanceViewer",
@@ -187731,6 +188063,167 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false, on
   return locator;
 }
 __name$8(rootLocatorFromConfig, "rootLocatorFromConfig");
+var apiNeeds = {
+  required: [
+    AccountBalanceViewerMoniker,
+    BlockViewerMoniker,
+    FinalizationViewerMoniker,
+    MempoolViewerMoniker,
+    TransactionViewerMoniker,
+    XyoConnectionMoniker$1,
+    XyoGatewayMoniker,
+    XyoRunnerMoniker,
+    XyoViewerMoniker
+  ]
+};
+var mempoolNeeds = {
+  required: [
+    MempoolRunnerMoniker,
+    // SimpleMempoolRunner.dependencies includes TransactionValidationViewer
+    // — not resolved by the actor directly but pulled in at construction.
+    TransactionValidationViewerMoniker,
+    // SimpleMempoolViewer.dependencies includes WindowedBlockViewer — the
+    // mempool viewer is built when api/finalizer resolve MempoolViewer.
+    WindowedBlockViewerMoniker
+  ]
+};
+var finalizerNeeds = {
+  required: [
+    BlockValidationViewerMoniker,
+    BlockViewerMoniker,
+    FinalizationRunnerMoniker,
+    MempoolViewerMoniker
+  ],
+  optional: [
+    DeadLetterQueueRunnerMoniker
+  ]
+};
+var ACTOR_MIRRORS = {
+  api: apiNeeds,
+  mempool: mempoolNeeds,
+  finalizer: finalizerNeeds
+};
+var apiExtraDescriptors = [
+  {
+    id: "SimpleXyoRunner",
+    satisfies: [
+      XyoRunnerMoniker
+    ],
+    tier: 1,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name$8(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name$8(() => SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleXyoConnectionRunner",
+    satisfies: [
+      XyoConnectionMoniker$1
+    ],
+    // Same tier as `SimpleXyoConnectionViewer`; higher priority wins the
+    // `XyoConnection` moniker in any actor mix that includes the API.
+    tier: 1,
+    priority: 100,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name$8(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name$8(() => SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleXyoGateway",
+    satisfies: [
+      XyoGatewayMoniker
+    ],
+    tier: 1,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name$8(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name$8(() => SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {}), "build")
+  }
+];
+var ACTOR_EXTRA_DESCRIPTORS = {
+  api: apiExtraDescriptors
+};
+var ACTOR_CONFIG_PARSERS = {
+  api: ApiConfigZod,
+  mempool: MempoolConfigZod,
+  finalizer: FinalizerConfigZod
+};
+var SHARED_LOCATOR_SUPPORTED_ACTORS = [
+  "api",
+  "mempool",
+  "finalizer"
+];
+function canUseSharedLocator(actors, config) {
+  if (actors.length === 0) return false;
+  if (config.remote?.rpc) return false;
+  const names = new Set(actors.map((a) => a.name));
+  const fullCanary = SHARED_LOCATOR_SUPPORTED_ACTORS.every((name) => names.has(name));
+  if (!fullCanary) return false;
+  return actors.every((actor) => {
+    if (!SHARED_LOCATOR_SUPPORTED_ACTORS.includes(actor.name)) return false;
+    if (actor.name === "api") {
+      const merged = ApiConfigZod.parse(deepMerge$1(config, actor));
+      if (merged.stateless === true) return false;
+    }
+    return true;
+  });
+}
+__name$8(canUseSharedLocator, "canUseSharedLocator");
+async function sharedLocatorFromConfig(context, actors, config, options = {}) {
+  const unionNeeds2 = {
+    required: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.required ?? [])),
+    optional: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.optional ?? []))
+  };
+  const extraDescriptors = actors.flatMap((a) => ACTOR_EXTRA_DESCRIPTORS[a.name] ?? []);
+  const commonContext = {
+    ...context,
+    config: {
+      ...config,
+      name: "_shared_common"
+    }
+  };
+  const commonLocator = await commonLocatorFromConfig(commonContext);
+  const sharedContext = {
+    ...commonLocator.context,
+    config: {
+      ...config,
+      name: "_shared"
+    }
+  };
+  const result = await locatorFromActorNeeds(sharedContext, [
+    unionNeeds2
+  ], {
+    extraDescriptors,
+    onInsecureGenesisConfirm: options.onInsecureGenesisConfirm,
+    validateDepsOnRegister: false
+  });
+  const sharedWithEvm = await initEvmProvidersIfAvailable(result.locator);
+  sharedWithEvm.freeze();
+  const perActor = {};
+  for (const actor of actors) {
+    const parser = ACTOR_CONFIG_PARSERS[actor.name];
+    const actorConfig = parser ? parser.parse(deepMerge$1(config, actor)) : actor;
+    const actorContext = {
+      ...sharedWithEvm.context,
+      config: actorConfig
+    };
+    const view = new ProviderFactoryLocator(actorContext, sharedWithEvm.registry);
+    view.freeze();
+    perActor[actor.name] = view;
+  }
+  return {
+    shared: sharedWithEvm,
+    perActor
+  };
+}
+__name$8(sharedLocatorFromConfig, "sharedLocatorFromConfig");
+function dedupe(items) {
+  return [
+    ...new Set(items)
+  ];
+}
+__name$8(dedupe, "dedupe");
 
 // src/node/config/locators/locatorsFromConfig.ts
 function allActorsAreSelfSufficient(actors, config) {
@@ -187744,6 +188237,12 @@ function allActorsAreSelfSufficient(actors, config) {
 __name$8(allActorsAreSelfSufficient, "allActorsAreSelfSufficient");
 async function locatorsFromConfig(context, { actors, ...config }, onInsecureGenesisConfirm) {
   const result = {};
+  if (canUseSharedLocator(actors, config)) {
+    const { perActor } = await sharedLocatorFromConfig(context, actors, config, {
+      onInsecureGenesisConfirm
+    });
+    return perActor;
+  }
   const skipRoot = allActorsAreSelfSufficient(actors, config);
   if (!skipRoot) {
     const rootContext = {
@@ -213763,7 +214262,7 @@ if (!nativeAccelerationDisabled) {
 	}
 }
 
-const version$1 = '5.76.6';
+const version$1 = '5.76.8';
 
 /**
  * Includes all the scripts needed by the queue and jobs.
@@ -217230,6 +217729,18 @@ local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, st
             nextMillis = nextMillis > now and nextMillis or now
         else
             nextMillis = now
+            -- For the first iteration with no startDate and an explicit
+            -- offset, align nextMillis to the next offset slot strictly
+            -- after now. Without this the user-supplied offset is
+            -- recorded but ignored, and the first job fires at now
+            -- instead of the next aligned timestamp (issue #3705).
+            if offset and offset > 0 then
+                local aligned = math.floor(nextMillis / every) * every + offset
+                if aligned <= nextMillis then
+                    aligned = aligned + every
+                end
+                nextMillis = aligned
+            end
         end
     else
         nextMillis = prevMillis + every
@@ -217872,7 +218383,7 @@ const addParentJob = {
 };
 
 const content$K = `--[[
-  Adds a priotitized job to the queue by doing the following:
+  Adds a prioritized job to the queue by doing the following:
     - Increases the job counter if needed.
     - Creates a new job key with the job data.
     - Adds the job to the "added" list so that workers gets notified.
@@ -220076,7 +220587,7 @@ const content$D = `--[[
     ARGV[2]  lock duration in milliseconds
     ARGV[3]  jobid
   Output:
-    "1" if lock extented succesfully.
+    "1" if lock extended successfully.
 ]]
 local rcall = redis.call
 if rcall("GET", KEYS[1]) == ARGV[1] then
@@ -221007,7 +221518,7 @@ if rcall("EXISTS", stalledCheckKey) == 1 then
     return {}
 end
 rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
--- Trim events before emiting them to avoid trimming events emitted in this script
+-- Trim events before emitting them to avoid trimming events emitted in this script
 trimEvents(metaKey, eventStreamKey)
 -- Move all stalled jobs to wait
 local stalling = rcall('SMEMBERS', stalledKey)
@@ -221706,7 +222217,7 @@ const moveToDelayed = {
 };
 
 const content$k = `--[[
-  Move job from active to a finished status (completed o failed)
+  Move job from active to a finished status (completed or failed)
   A job can only be moved to completed if it was active.
   The job must be locked before it can be moved to a finished status,
   and the lock must be released in this script.
@@ -221760,7 +222271,7 @@ local rcall = redis.call
 --- Includes
 --[[
   Functions to collect metrics based on a current and previous count of jobs.
-  Granualarity is fixed at 1 minute.
+  Granularity is fixed at 1 minute.
 ]]
 --[[
   Function to loop in batches.
@@ -222640,7 +223151,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     end
     local eventStreamKey = KEYS[4]
     local metaKey = KEYS[9]
-    -- Trim events before emiting them to avoid trimming events emitted in this script
+    -- Trim events before emitting them to avoid trimming events emitted in this script
     trimEvents(metaKey, eventStreamKey)
     local prefix = ARGV[7]
     removeDeduplicationKeyIfNeededOnFinalization(prefix, jobAttributes[3], jobId)
@@ -222850,7 +223361,7 @@ const content$i = `--[[
   keys, consider that this call may be slow for very large queues.
   The queue needs to be "paused" or it will return an error
   If the queue has currently active jobs then the script by default will return error,
-  however this behaviour can be overrided using the 'force' option.
+  however this behaviour can be overridden using the 'force' option.
   Input:
     KEYS[1] meta
     KEYS[2] base
@@ -223292,15 +223803,15 @@ const paginate = {
 };
 
 const content$g = `--[[
-  Pauses or resumes a queue globably.
+  Pauses or resumes a queue globally.
   Input:
-    KEYS[1] 'wait' or 'paused''
+    KEYS[1] 'wait' or 'paused'
     KEYS[2] 'paused' or 'wait'
     KEYS[3] 'meta'
     KEYS[4] 'prioritized'
     KEYS[5] events stream key
     KEYS[6] 'delayed'
-    KEYS|7] 'marker'
+    KEYS[7] 'marker'
     ARGV[1] 'paused' or 'resumed'
   Event:
     publish paused or resumed event.
@@ -223469,7 +223980,7 @@ const content$e = `--[[
       ARGV[1]  token
       ARGV[2]  lock duration in milliseconds
     Output:
-      "OK" if lock extented succesfully.
+      "OK" if lock extended successfully.
 ]]
 local rcall = redis.call
 if rcall("GET", KEYS[1]) == ARGV[1] then
@@ -225160,6 +225671,18 @@ local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, st
             nextMillis = nextMillis > now and nextMillis or now
         else
             nextMillis = now
+            -- For the first iteration with no startDate and an explicit
+            -- offset, align nextMillis to the next offset slot strictly
+            -- after now. Without this the user-supplied offset is
+            -- recorded but ignored, and the first job fires at now
+            -- instead of the next aligned timestamp (issue #3705).
+            if offset and offset > 0 then
+                local aligned = math.floor(nextMillis / every) * every + offset
+                if aligned <= nextMillis then
+                    aligned = aligned + every
+                end
+                nextMillis = aligned
+            end
         end
     else
         nextMillis = prevMillis + every
@@ -235752,7 +236275,7 @@ class JobScheduler extends QueueBase {
         // Check if we have a start date for the repeatable job
         const { immediately } = repeatOpts, filteredRepeatOpts = __rest(repeatOpts, ["immediately"]);
         let nextMillis;
-        const newOffset = null;
+        const newOffset = every && offset ? offset : null;
         if (pattern) {
             nextMillis = await this.repeatStrategy(now, repeatOpts, jobName);
             if (nextMillis < now) {
@@ -236201,7 +236724,7 @@ class QueueGetters extends QueueBase {
     /**
      * Returns the time to live for a rate limited key in milliseconds.
      * @param maxJobs - max jobs to be considered in rate limit state. If not passed
-     * it will return the remaining ttl without considering if max jobs is excedeed.
+     * it will return the remaining ttl without considering if max jobs is exceeded.
      * @returns -2 if the key does not exist.
      * -1 if the key exists but has no associated expire.
      * @see {@link https://redis.io/commands/pttl/}
@@ -248881,6 +249404,39 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var deepMerge = createDeepMerge({
   arrayStrategy: "concat"
 });
+var REDACTED = "[REDACTED]";
+var REDACTED_KEY_NAMES = /* @__PURE__ */ new Set([
+  "mnemonic",
+  "connectionString"
+]);
+var REDACTED_KEY_SUFFIX = /(PrivateKey|Secret|Password)$/i;
+function shouldRedactKey(key) {
+  if (REDACTED_KEY_NAMES.has(key)) return true;
+  return REDACTED_KEY_SUFFIX.test(key);
+}
+__name(shouldRedactKey, "shouldRedactKey");
+function redactConfig(config2) {
+  const cloned = structuredClone(config2);
+  redactInPlace(cloned);
+  return cloned;
+}
+__name(redactConfig, "redactConfig");
+function redactInPlace(node) {
+  if (Array.isArray(node)) {
+    for (const item of node) redactInPlace(item);
+    return;
+  }
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    if (shouldRedactKey(key) && obj[key] !== void 0 && obj[key] !== null) {
+      obj[key] = REDACTED;
+    } else {
+      redactInPlace(obj[key]);
+    }
+  }
+}
+__name(redactInPlace, "redactInPlace");
 function coerceActorsArray(argv) {
   const actors = argv.actors;
   if (actors === void 0 || Array.isArray(actors)) return argv;
@@ -248929,7 +249485,9 @@ async function configMiddleware(argv, setConfiguration) {
     assertNoActorMnemonics(finalConfig);
     setConfiguration(finalConfig);
     if (argv["dump-config"]) {
-      console.log(JSON.stringify(finalConfig, null, 2));
+      const withSecrets = Boolean(argv["with-secrets"]);
+      const output2 = withSecrets ? finalConfig : redactConfig(finalConfig);
+      console.log(JSON.stringify(output2, null, 2));
       process.exit(0);
     }
   } catch (err) {
@@ -249078,6 +249636,176 @@ function withDeprecationWarning(module) {
 }
 __name(withDeprecationWarning, "withDeprecationWarning");
 
+// src/dumpProviders.ts
+var CANONICAL_ACTOR_ORDER = [
+  "_root",
+  "producer",
+  "finalizer",
+  "api",
+  "mempool",
+  "bridge",
+  "rewardRedemption"
+];
+function enumerateLocator(locator) {
+  const collapsed = /* @__PURE__ */ new Map();
+  const registry = locator.registry;
+  for (const moniker of Object.keys(registry)) {
+    const factories = registry[moniker];
+    if (!factories) continue;
+    for (const factory of factories) {
+      const f = factory;
+      const providerName = f.providerName ?? "<unknown>";
+      const scope = f.scope ?? "<unknown>";
+      const dependencies = f.dependencies ?? [];
+      const fingerprint = `${moniker}|${providerName}|${scope}|${dependencies.join(",")}`;
+      const existing = collapsed.get(fingerprint);
+      if (existing) {
+        existing.count += 1;
+      } else {
+        collapsed.set(fingerprint, {
+          count: 1,
+          dependencies,
+          moniker,
+          providerName,
+          scope
+        });
+      }
+    }
+  }
+  return [
+    ...collapsed.values()
+  ].toSorted((a, b) => a.moniker.localeCompare(b.moniker) || a.providerName.localeCompare(b.providerName));
+}
+__name(enumerateLocator, "enumerateLocator");
+function buildOwnerIndex(perActor) {
+  const monikerOwners = /* @__PURE__ */ new Map();
+  for (const [actorName, entries] of perActor) {
+    for (const entry of entries) {
+      let owners = monikerOwners.get(entry.moniker);
+      if (!owners) {
+        owners = /* @__PURE__ */ new Set();
+        monikerOwners.set(entry.moniker, owners);
+      }
+      owners.add(actorName);
+    }
+  }
+  return monikerOwners;
+}
+__name(buildOwnerIndex, "buildOwnerIndex");
+function renderDuplicatesSummary(monikerOwners) {
+  const duplicates = [
+    ...monikerOwners.entries()
+  ].filter(([, owners]) => owners.size > 1).map(([moniker, owners]) => ({
+    moniker,
+    owners: [
+      ...owners
+    ].toSorted().map(formatGroupForDisplay)
+  })).toSorted((a, b) => a.moniker.localeCompare(b.moniker));
+  if (duplicates.length === 0) return [];
+  const lines = [
+    "Duplicate monikers (registered by more than one locator):"
+  ];
+  for (const { moniker, owners } of duplicates) {
+    lines.push(`  - ${moniker}: ${owners.join(", ")}`);
+  }
+  lines.push("");
+  return lines;
+}
+__name(renderDuplicatesSummary, "renderDuplicatesSummary");
+function groupActorsBySharedRegistry(locators) {
+  const groups = [];
+  for (const actorName of Object.keys(locators)) {
+    const locator = locators[actorName];
+    const existing = groups.find((g) => g.registry === locator.registry);
+    if (existing) {
+      existing.actorNames.push(actorName);
+    } else {
+      groups.push({
+        actorNames: [
+          actorName
+        ],
+        locator,
+        registry: locator.registry
+      });
+    }
+  }
+  return groups;
+}
+__name(groupActorsBySharedRegistry, "groupActorsBySharedRegistry");
+function groupId(actorNames) {
+  return [
+    ...actorNames
+  ].toSorted().join(",");
+}
+__name(groupId, "groupId");
+function formatGroupForDisplay(groupKey) {
+  const members = groupKey.split(",");
+  return members.length === 1 ? members[0] : `(${members.join(", ")})`;
+}
+__name(formatGroupForDisplay, "formatGroupForDisplay");
+function renderGroupSection(actorNames, entries, monikerOwners) {
+  const sortedActors = [
+    ...actorNames
+  ].toSorted();
+  const ownGroupKey = groupId(sortedActors);
+  const heading = sortedActors.length === 1 ? `Providers for actor: ${sortedActors[0]}  (${entries.length} registered)` : `Providers shared by actors: ${sortedActors.join(", ")}  (${entries.length} registered)`;
+  const lines = [
+    heading
+  ];
+  if (entries.length === 0) {
+    lines.push("  (none)", "");
+    return lines;
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const isLast = i === entries.length - 1;
+    const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    const owners = monikerOwners.get(entry.moniker) ?? /* @__PURE__ */ new Set();
+    const otherOwners = [
+      ...owners
+    ].filter((o) => o !== ownGroupKey).toSorted().map(formatGroupForDisplay);
+    const dupNote = otherOwners.length > 0 ? `   \u26A0 also in: ${otherOwners.join(", ")}` : "";
+    const depsNote = entry.dependencies.length > 0 ? `, deps: [${entry.dependencies.join(", ")}]` : "";
+    const countNote = entry.count > 1 ? ` (\xD7${entry.count})` : "";
+    lines.push(`  ${branch} ${entry.moniker}${countNote}  [impl: ${entry.providerName}, scope: ${entry.scope}${depsNote}]${dupNote}`);
+  }
+  lines.push("");
+  return lines;
+}
+__name(renderGroupSection, "renderGroupSection");
+function formatProviderTree(locators) {
+  const groups = groupActorsBySharedRegistry(locators);
+  const groupKeys = groups.map((g) => ({
+    ...g,
+    key: groupId(g.actorNames)
+  }));
+  const perGroup = /* @__PURE__ */ new Map();
+  for (const g of groupKeys) perGroup.set(g.key, enumerateLocator(g.locator));
+  const monikerOwners = buildOwnerIndex(perGroup);
+  const orderedGroups = [
+    ...groupKeys
+  ].toSorted((a, b) => {
+    const aHasRoot = a.actorNames.includes("_root");
+    const bHasRoot = b.actorNames.includes("_root");
+    if (aHasRoot !== bHasRoot) return aHasRoot ? -1 : 1;
+    const ai = CANONICAL_ACTOR_ORDER.indexOf(a.actorNames[0]);
+    const bi = CANONICAL_ACTOR_ORDER.indexOf(b.actorNames[0]);
+    if (ai !== bi) return (ai === -1 ? Number.MAX_SAFE_INTEGER : ai) - (bi === -1 ? Number.MAX_SAFE_INTEGER : bi);
+    return a.key.localeCompare(b.key);
+  });
+  const lines = [
+    "XL1 Provider Dump",
+    "=================",
+    ""
+  ];
+  for (const g of orderedGroups) {
+    lines.push(...renderGroupSection(g.actorNames.toSorted(), perGroup.get(g.key) ?? [], monikerOwners));
+  }
+  lines.push(...renderDuplicatesSummary(monikerOwners));
+  return lines.join("\n");
+}
+__name(formatProviderTree, "formatProviderTree");
+
 // src/images.ts
 var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;118;111;144m_\x1B[0m
 \x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;72;32;223m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m
@@ -249121,7 +249849,8 @@ function defaultScrapePortForActors(actors) {
 __name(defaultScrapePortForActors, "defaultScrapePortForActors");
 var configuration;
 var skipInsecureConfirm = false;
-var version = isDefined("1.22.0") ? "1.22.0" : "unknown";
+var dumpProviders = false;
+var version = isDefined("1.23.0") ? "1.23.0" : "unknown";
 function getConfiguration() {
   return configuration;
 }
@@ -249174,6 +249903,10 @@ async function getLocatorsFromConfig(actors, configuration2) {
   }
   const onInsecureGenesisConfirm = skipInsecureConfirm ? void 0 : async () => await promptForInsecureGenesisConfirmation(logger);
   const locators = await locatorsFromConfig(context, config2, onInsecureGenesisConfirm);
+  if (dumpProviders) {
+    console.log(formatProviderTree(locators));
+    process.exit(0);
+  }
   const healthCheckPort = configuration2.healthCheckPort ?? DEFAULT_HEALTH_CHECK_PORT;
   const healthServer = healthCheckPort > 0 && context.statusReporter !== void 0 ? await initHealthEndpoints({
     logger,
@@ -249218,6 +249951,7 @@ $0 <command> [options]`).parserConfiguration({
       configuration = config2;
     });
     skipInsecureConfirm = Boolean(argv2["skip-insecure-confirm"]);
+    dumpProviders = Boolean(argv2["dump-providers"]);
   }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command(withDeprecationWarning(apiCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(bridgeCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(finalizerCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(mempoolCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(producerCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(rewardRedemptionCommand(getConfiguration, getLocatorsFromConfig))).command(startCommand(getConfiguration, getLocatorsFromConfig)).options({
     "config": {
       type: "string",
@@ -249230,7 +249964,17 @@ $0 <command> [options]`).parserConfiguration({
     },
     "dump-config": {
       type: "boolean",
-      description: "Just process the configuration and print the resolved config to stdout, then exit.",
+      description: "Just process the configuration and print the resolved config to stdout, then exit. Secrets are redacted unless --with-secrets is also passed.",
+      default: false
+    },
+    "with-secrets": {
+      type: "boolean",
+      description: 'When used with --dump-config, print raw secret values (mnemonic, private keys, passwords) instead of "[REDACTED]". Use only on a developer machine.',
+      default: false
+    },
+    "dump-providers": {
+      type: "boolean",
+      description: "Run the normal command flow up to provider locator construction, print the per-actor provider tree (with duplicate detection), then exit.",
       default: false
     },
     "skip-insecure-confirm": {