@xyo-network/chain-services 1.23.0 → 2.0.0

package/dist/neutral/index.mjs

@@ -1,26 +1,30 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/BlockReward/EvmBlockRewardViewer.ts
-import { AbstractCreatable, assertEx, creatable, toEthAddress } from "@xylabs/sdk-js";
+import {
+  AbstractCreatable,
+  assertEx,
+  creatable,
+  toEthAddress
+} from "@xylabs/sdk-js";
 import { IXyoChainRewards__factory } from "@xyo-network/typechain";
-import { asAttoXL1, BlockRewardViewerMoniker } from "@xyo-network/xl1-sdk";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable {
-  static {
-    __name(this, "EvmBlockRewardViewer");
-  }
-  static defaultMoniker = BlockRewardViewerMoniker;
-  static monikers = [
-    BlockRewardViewerMoniker
-  ];
-  moniker = _EvmBlockRewardViewer.defaultMoniker;
+import {
+  asAttoXL1,
+  BlockRewardViewerMoniker
+} from "@xyo-network/xl1-sdk";
+var EvmBlockRewardViewer = class extends AbstractCreatable {
+  moniker = EvmBlockRewardViewer.defaultMoniker;
   _contractAddress;
   get chainContractViewer() {
     return assertEx(this.params.chainContractViewer, () => "chainContractViewer is required");
@@ -41,22 +45,19 @@ var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable
       this._contractAddress = await this.chainContractViewer.rewardsContract();
     } catch (ex) {
       const error = ex;
-      throw new Error(`Failed to get rewards contract address: ${error.message}`, {
-        cause: ex
-      });
+      throw new Error(`Failed to get rewards contract address: ${error.message}`, { cause: ex });
     }
   }
 };
-EvmBlockRewardViewer = _ts_decorate([
+__publicField(EvmBlockRewardViewer, "defaultMoniker", BlockRewardViewerMoniker);
+__publicField(EvmBlockRewardViewer, "monikers", [BlockRewardViewerMoniker]);
+EvmBlockRewardViewer = __decorateClass([
   creatable()
 ], EvmBlockRewardViewer);
 
 // src/ChainValidator/XyoValidator.ts
 import { AbstractCreatableProvider, BlockViewerMoniker } from "@xyo-network/xl1-sdk";
 var XyoValidator = class extends AbstractCreatableProvider {
-  static {
-    __name(this, "XyoValidator");
-  }
   moniker = "Validator";
   _blockViewer;
   // get address() {
@@ -97,24 +98,12 @@ var XyoValidator = class extends AbstractCreatableProvider {
 // src/Election/BaseElectionService.ts
 import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
-import { AbstractCreatableProvider as AbstractCreatableProvider2, creatableProvider } from "@xyo-network/xl1-sdk";
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate2, "_ts_decorate");
-var BaseElectionService = class _BaseElectionService extends AbstractCreatableProvider2 {
-  static {
-    __name(this, "BaseElectionService");
-  }
-  static defaultMoniker = "Election";
-  static dependencies = [];
-  static monikers = [
-    "Election"
-  ];
-  moniker = _BaseElectionService.defaultMoniker;
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider2,
+  creatableProvider
+} from "@xyo-network/xl1-sdk";
+var BaseElectionService = class extends AbstractCreatableProvider2 {
+  moniker = BaseElectionService.defaultMoniker;
   get blockViewer() {
     return assertEx2(this.params.blockViewer, () => "No block viewer");
   }
@@ -139,32 +128,51 @@ var BaseElectionService = class _BaseElectionService extends AbstractCreatablePr
     return creatorArray.slice(0, maxSize);
   }
 };
-BaseElectionService = _ts_decorate2([
+__publicField(BaseElectionService, "defaultMoniker", "Election");
+__publicField(BaseElectionService, "dependencies", []);
+__publicField(BaseElectionService, "monikers", ["Election"]);
+BaseElectionService = __decorateClass([
   creatableProvider()
 ], BaseElectionService);
 
 // src/implementation/head/createBootstrapHead.ts
 import { buildNextBlock, createGenesisBlock } from "@xyo-network/chain-protocol";
 import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
-var createBootstrapHead = /* @__PURE__ */ __name(async (account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
+var createBootstrapHead = async (account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
   const chain = [];
   const genesisBlock = await createGenesisBlock(account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress);
   chain.push(genesisBlock);
-  const producerDeclarationPayload = createDeclarationIntent(account.address, "producer", genesisBlock[0].block, genesisBlock[0].block + 1e4);
-  const producerDeclarationBlock = await buildNextBlock(genesisBlock[0], [], [
-    producerDeclarationPayload
-  ], [
-    account
-  ]);
+  const producerDeclarationPayload = createDeclarationIntent(
+    account.address,
+    "producer",
+    genesisBlock[0].block,
+    genesisBlock[0].block + 1e4
+  );
+  const producerDeclarationBlock = await buildNextBlock(
+    genesisBlock[0],
+    [],
+    [producerDeclarationPayload],
+    [account]
+  );
   chain.push(producerDeclarationBlock);
   return chain;
-}, "createBootstrapHead");
+};
 
 // src/implementation/processPendingBlocks.ts
 import { assertEx as assertEx3, isDefined } from "@xylabs/sdk-js";
 import { ChainHeadSelector } from "@xyo-network/chain-analyze";
 import { BlockRejectionSchema, isSignedHydratedBlockWithHashMeta } from "@xyo-network/xl1-sdk";
-async function processPendingBlocks({ blockValidationViewer, blockViewer, context, logger, mempoolViewer, finalizationRunner, allowedProducers, minCandidates, deadLetterQueueRunner }) {
+async function processPendingBlocks({
+  blockValidationViewer,
+  blockViewer,
+  context,
+  logger,
+  mempoolViewer,
+  finalizationRunner,
+  allowedProducers,
+  minCandidates,
+  deadLetterQueueRunner
+}) {
   const start = Date.now();
   const currentBlock = await blockViewer.currentBlock();
   const headSelector = new ChainHeadSelector({
@@ -172,9 +180,7 @@ async function processPendingBlocks({ blockValidationViewer, blockViewer, contex
     logger,
     mempoolViewer,
     blockViewer,
-    windowedFinalizedChain: [
-      currentBlock
-    ],
+    windowedFinalizedChain: [currentBlock],
     allowedProducers,
     minCandidates
   });
@@ -192,12 +198,7 @@ async function processPendingBlocks({ blockValidationViewer, blockViewer, contex
     const candidateBlocks = bestHeadChain.filter((b) => {
       return isDefined(oldHeadBlock) ? b[0].block > oldHeadBlock.block : true;
     });
-    const validationResults = await Promise.all(candidateBlocks.map((candidateBlock) => blockValidationViewer.validateBlocks([
-      candidateBlock
-    ], {
-      value: true,
-      state: true
-    })));
+    const validationResults = await Promise.all(candidateBlocks.map((candidateBlock) => blockValidationViewer.validateBlocks([candidateBlock], { value: true, state: true })));
     const blocksToFinalize = [];
     for (const [i, block] of candidateBlocks.entries()) {
       const result = validationResults[i][0];
@@ -210,12 +211,7 @@ async function processPendingBlocks({ blockValidationViewer, blockViewer, contex
             hash: block[0]._hash,
             name: "BlockValidationError",
             message: String(e.message ?? e)
-          })) : [
-            {
-              hash: block[0]._hash,
-              name: "BlockValidationError"
-            }
-          ];
+          })) : [{ hash: block[0]._hash, name: "BlockValidationError" }];
           await deadLetterQueueRunner.rejectBlock({
             schema: BlockRejectionSchema,
             block,
@@ -236,27 +232,15 @@ async function processPendingBlocks({ blockValidationViewer, blockViewer, contex
     logger?.info("No head found to validate", currentBlock?.[0]._hash);
   }
 }
-__name(processPendingBlocks, "processPendingBlocks");
 
 // src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts
-import { AbstractCreatableProvider as AbstractCreatableProvider3, creatableProvider as creatableProvider2, NetworkStakeStepRewardViewerMoniker } from "@xyo-network/xl1-sdk";
-function _ts_decorate3(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate3, "_ts_decorate");
-var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService extends AbstractCreatableProvider3 {
-  static {
-    __name(this, "BaseNetworkStakeStepRewardService");
-  }
-  static defaultMoniker = NetworkStakeStepRewardViewerMoniker;
-  static dependencies = [];
-  static monikers = [
-    NetworkStakeStepRewardViewerMoniker
-  ];
-  moniker = _BaseNetworkStakeStepRewardService.defaultMoniker;
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider3,
+  creatableProvider as creatableProvider2,
+  NetworkStakeStepRewardViewerMoniker
+} from "@xyo-network/xl1-sdk";
+var BaseNetworkStakeStepRewardService = class extends AbstractCreatableProvider3 {
+  moniker = BaseNetworkStakeStepRewardService.defaultMoniker;
   networkStakeStepRewardAddressHistory(_address) {
     throw new Error("Method [networkStakeStepRewardAddressHistory] not implemented.");
   }
@@ -312,28 +296,62 @@ var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService
     throw new Error("Method [networkStakeStepRewardsForStepLevel] not implemented.");
   }
 };
-BaseNetworkStakeStepRewardService = _ts_decorate3([
+__publicField(BaseNetworkStakeStepRewardService, "defaultMoniker", NetworkStakeStepRewardViewerMoniker);
+__publicField(BaseNetworkStakeStepRewardService, "dependencies", []);
+__publicField(BaseNetworkStakeStepRewardService, "monikers", [NetworkStakeStepRewardViewerMoniker]);
+BaseNetworkStakeStepRewardService = __decorateClass([
   creatableProvider2()
 ], BaseNetworkStakeStepRewardService);
 
 // src/simple/block/runner/SimpleBlockRunner.ts
-import { assertEx as assertEx5, exists, hexToBigInt, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx5,
+  exists,
+  hexToBigInt,
+  isDefined as isDefined2
+} from "@xylabs/sdk-js";
 import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "@xyo-network/chain-modules";
 import { buildNextBlock as buildNextBlock2 } from "@xyo-network/chain-protocol";
-import { MemoryArchivist, PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
-import { AbstractCreatableProvider as AbstractCreatableProvider4, AccountBalanceViewerMoniker, asBlockBoundWitness, AttoXL1, BlockNumberSchema, BlockRejectionSchema as BlockRejectionSchema2, BlockRewardViewerMoniker as BlockRewardViewerMoniker2, BlockRunnerMoniker, BlockValidationViewerMoniker, creatableProvider as creatableProvider3, createDeclarationIntent as createDeclarationIntent2, DeadLetterQueueRunnerMoniker, defaultRewardRatio, FinalizationViewerMoniker, isSignedHydratedBlockWithHashMeta as isSignedHydratedBlockWithHashMeta2, MempoolRunnerMoniker, MempoolViewerMoniker, TimeSyncViewerMoniker, TransactionRejectionSchema, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-sdk";
+import {
+  MemoryArchivist,
+  PayloadBuilder as PayloadBuilder2
+} from "@xyo-network/sdk-js";
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider4,
+  AccountBalanceViewerMoniker,
+  asBlockBoundWitness,
+  AttoXL1,
+  BlockNumberSchema,
+  BlockRejectionSchema as BlockRejectionSchema2,
+  BlockRewardViewerMoniker as BlockRewardViewerMoniker2,
+  BlockRunnerMoniker,
+  BlockValidationViewerMoniker,
+  creatableProvider as creatableProvider3,
+  createDeclarationIntent as createDeclarationIntent2,
+  DeadLetterQueueRunnerMoniker,
+  defaultRewardRatio,
+  FinalizationViewerMoniker,
+  isSignedHydratedBlockWithHashMeta as isSignedHydratedBlockWithHashMeta2,
+  isTransfer,
+  MempoolViewerMoniker,
+  TimeSyncViewerMoniker,
+  TransactionRejectionSchema,
+  XYO_STEP_REWARD_ADDRESS
+} from "@xyo-network/xl1-sdk";
 
 // src/simple/block/runner/generateTransactionFeeTransfers.ts
 import { hexFromBigInt } from "@xylabs/sdk-js";
 import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { HydratedTransactionWrapper, transactionRequiredGas, TransferSchema, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
+import {
+  HydratedTransactionWrapper,
+  transactionRequiredGas,
+  TransferSchema,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-sdk";
 async function generateTransactionFeeTransfers(address, transactions) {
   const txs = await Promise.all(transactions.map(async (tx) => {
-    return HydratedTransactionWrapper.parse([
-      await PayloadBuilder.addStorageMeta(tx[0]),
-      await PayloadBuilder.addStorageMeta(tx[1])
-    ]);
+    return HydratedTransactionWrapper.parse([await PayloadBuilder.addStorageMeta(tx[0]), await PayloadBuilder.addStorageMeta(tx[1])]);
   }));
   const txBaseFeeCosts = {};
   for (const tx of txs) {
@@ -363,27 +381,24 @@ async function generateTransactionFeeTransfers(address, transactions) {
   }
   return payloads;
 }
-__name(generateTransactionFeeTransfers, "generateTransactionFeeTransfers");
 
 // src/simple/block/runner/identifyOffendingTransactions.ts
-import { HydratedTransactionWrapper as HydratedTransactionWrapper2, netBalancesForPayloads, transactionRequiredGas as transactionRequiredGas2 } from "@xyo-network/xl1-sdk";
+import {
+  HydratedTransactionWrapper as HydratedTransactionWrapper2,
+  netBalancesForPayloads,
+  transactionRequiredGas as transactionRequiredGas2
+} from "@xyo-network/xl1-sdk";
 async function scoreTransaction(tx) {
   const wrapper = await HydratedTransactionWrapper2.parse(tx);
   const from = wrapper.boundWitness.from;
   const gasPrice = wrapper.fees.gasPrice;
   const gasCost = transactionRequiredGas2(tx) * gasPrice;
   const baseCost = wrapper.fees.base;
-  const netBalances = netBalancesForPayloads({
-    singletons: {}
-  }, tx[1]);
+  const netBalances = netBalancesForPayloads({ singletons: {} }, tx[1]);
   const fromNet = netBalances[from] ?? 0n;
   const transferOut = fromNet < 0n ? -fromNet : 0n;
-  return {
-    cost: gasCost + baseCost + transferOut,
-    gasPrice
-  };
+  return { cost: gasCost + baseCost + transferOut, gasPrice };
 }
-__name(scoreTransaction, "scoreTransaction");
 async function identifyOffendingTransactions(args) {
   const { errors, candidateTransactions } = args;
   const candidateHashes = new Set(candidateTransactions.map((tx) => tx[0]._hash));
@@ -394,12 +409,7 @@ async function identifyOffendingTransactions(args) {
     if (cause?.hash && candidateHashes.has(cause.hash)) txInvalidHashes.add(cause.hash);
   }
   if (txInvalidHashes.size > 0) {
-    return {
-      offendingHashes: [
-        ...txInvalidHashes
-      ],
-      reason: "tx-invalid"
-    };
+    return { offendingHashes: [...txInvalidHashes], reason: "tx-invalid" };
   }
   const balanceOffenderHashes = /* @__PURE__ */ new Set();
   for (const error of errors) {
@@ -409,59 +419,24 @@ async function identifyOffendingTransactions(args) {
     }
   }
   if (balanceOffenderHashes.size === 0) {
-    return {
-      offendingHashes: [],
-      reason: "unknown"
-    };
+    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)
-  })));
+  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"
-  };
+  return { offendingHashes: [scored[0].tx[0]._hash], reason: "block-balance" };
 }
-__name(identifyOffendingTransactions, "identifyOffendingTransactions");
 
 // src/simple/block/runner/SimpleBlockRunner.ts
-function _ts_decorate4(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate4, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 100;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 100;
-var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvider4 {
-  static {
-    __name(this, "SimpleBlockRunner");
-  }
-  static defaultMoniker = BlockRunnerMoniker;
-  static dependencies = [
-    AccountBalanceViewerMoniker,
-    BlockRewardViewerMoniker2,
-    BlockValidationViewerMoniker,
-    FinalizationViewerMoniker,
-    MempoolRunnerMoniker,
-    MempoolViewerMoniker,
-    TimeSyncViewerMoniker
-  ];
-  static monikers = [
-    BlockRunnerMoniker
-  ];
-  moniker = _SimpleBlockRunner.defaultMoniker;
+var SimpleBlockRunner = class extends AbstractCreatableProvider4 {
+  moniker = SimpleBlockRunner.defaultMoniker;
   _blockRewardDiviner;
   _deadLetterQueueRunner;
   // TODO(producer-exclusion-set): uncapped for v1. If memory grows in long-running producers,
@@ -475,27 +450,26 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   _blockRewardViewer;
   _blockValidationViewer;
   _finalizationViewer;
-  _mempoolRunner;
   _mempoolViewer;
   _rewardAddress;
   _timeSyncViewer;
   /**
-  * The default block size for a block
-  */
+   * The default block size for a block
+   */
   static get DefaultBlockSize() {
     return DEFAULT_BLOCK_SIZE;
   }
   /**
-  * The amount of time for which the producer will redeclare
-  * their intent to continue producing blocks
-  */
+   * The amount of time for which the producer will redeclare
+   * their intent to continue producing blocks
+   */
   static get RedeclarationDuration() {
     return XYO_PRODUCER_REDECLARATION_DURATION;
   }
   /**
-  * The number of blocks within which the producer will redeclare
-  * their intent to continue producing blocks
-  */
+   * The number of blocks within which the producer will redeclare
+   * their intent to continue producing blocks
+   */
   static get RedeclarationWindow() {
     return XYO_PRODUCER_REDECLARATION_WINDOW;
   }
@@ -520,9 +494,6 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
   get heartbeatInterval() {
     return this.params.heartbeatInterval ?? 36e5;
   }
-  get mempoolRunner() {
-    return this._mempoolRunner;
-  }
   get mempoolViewer() {
     return this._mempoolViewer;
   }
@@ -552,7 +523,6 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
     this._blockRewardViewer = await this.locateAndCreate(BlockRewardViewerMoniker2);
     this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker);
     this._finalizationViewer = await this.locateAndCreate(FinalizationViewerMoniker);
-    this._mempoolRunner = await this.locateAndCreate(MempoolRunnerMoniker);
     this._mempoolViewer = await this.locateAndCreate(MempoolViewerMoniker);
     this._rewardAddress = this.params.rewardAddress;
     this._timeSyncViewer = await this.locateAndCreate(TimeSyncViewerMoniker);
@@ -577,40 +547,43 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         }
       });
     }
-    const blockId = new PayloadBuilder2({
-      schema: BlockNumberSchema
-    }).fields({
-      block
-    }).build();
-    const rewards = await this._blockRewardDiviner.divine([
-      blockId
-    ]);
+    const blockId = new PayloadBuilder2({ schema: BlockNumberSchema }).fields({ block }).build();
+    const rewards = await this._blockRewardDiviner.divine([blockId]);
     return rewards;
   }
   /**
-  * Handles the producer redeclaration logic
-  * @param head The current head block
-  * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
-  */
+   * Handles the producer redeclaration logic
+   * @param head The current head block
+   * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
+   */
   getProducerRedeclaration(head) {
     if (this.params.disableIntentRedeclaration) return;
     const currentBlock = head.block;
     if (isDefined2(this._lastRedeclarationBlock)) {
-      const lastDeclarationExpiry = this._lastRedeclarationBlock + _SimpleBlockRunner.RedeclarationDuration;
+      const lastDeclarationExpiry = this._lastRedeclarationBlock + SimpleBlockRunner.RedeclarationDuration;
       if (currentBlock < lastDeclarationExpiry) return;
     }
     this._lastRedeclarationBlock = currentBlock;
-    return createDeclarationIntent2(this.address, "producer", currentBlock, currentBlock + _SimpleBlockRunner.RedeclarationDuration);
-  }
-  async proposeNextValidBlock(head, validateBalances = false, force = false) {
+    return createDeclarationIntent2(this.address, "producer", currentBlock, currentBlock + SimpleBlockRunner.RedeclarationDuration);
+  }
+  // `validateBalances` resolves from (a) the explicit method argument when
+  // passed, (b) the constructor `params.validateBalances`, or (c) `true`.
+  // True is the safe default: `filterByFunded` then enforces the same
+  // cumulative-outflow rule the post-submit block validator uses
+  // (`base + priority + gasLimit + transfer amounts`). With the old default
+  // of `false`, a tx whose declared gasLimit exceeded the sender's balance
+  // would pass the producer's filter, get submitted, and then land in
+  // `rejected_blocks` — silently wedging the chain because the producer's
+  // `_lastProducedBlock` cache muted retries. Reproduced in the
+  // api-local-mongodb-beta test rig.
+  async proposeNextValidBlock(head, validateBalances, force = false) {
+    const shouldValidateBalances = validateBalances ?? this.params.validateBalances ?? true;
     return await this.spanAsync("proposeNextValidBlock", async () => {
       try {
         const { block: previousBlock } = assertEx5(asBlockBoundWitness(head), () => "Invalid head block");
         const nextBlock = previousBlock + 1;
         const chainId = await this.finalizationViewer.chainId();
-        const pendingTransactionsRaw = await this.mempoolViewer.pendingTransactions({
-          limit: _SimpleBlockRunner.DefaultBlockSize
-        });
+        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}`);
@@ -627,10 +600,8 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
         if (timeDuration > 100) {
           this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`);
         }
-        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 [initialFundedTransactions, initialFundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, shouldValidateBalances);
+        const stepRewardPoolBalance = (await this.accountBalanceViewer.accountBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS];
         const result = await this.runBuildValidateRetryLoop({
           head,
           chainId,
@@ -641,9 +612,6 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
           initialFundedTransfers
         });
         if (isSignedHydratedBlockWithHashMeta2(result.block)) {
-          await this.mempoolRunner.submitBlocks([
-            result.block
-          ]);
           return result.block;
         }
         if (result.block) await this.rejectExhaustedBlock(result.block, result.errors);
@@ -653,39 +621,66 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
       }
     }, this.context);
   }
+  /**
+   * Compute the cumulative outflow a single tx would charge to its `from`
+   * address, using the same rule as `BlockCumulativeBalanceValidator`:
+   * `outflow = base + priority + gasLimit + sum(transfer amounts to addresses
+   * other than from)`. Mirroring the validator exactly here ensures the
+   * producer doesn't include a tx that the post-submit block validator will
+   * reject, which would otherwise wedge the chain because the producer's
+   * `_lastProducedBlock` cache mutes retries.
+   */
+  computeTransactionOutflow(tx) {
+    const [bw, payloads] = tx;
+    const {
+      base,
+      gasLimit,
+      priority
+    } = bw.fees;
+    let outflow = hexToBigInt(base) + hexToBigInt(priority) + hexToBigInt(gasLimit);
+    const txPayloadHashes = new Set(bw.payload_hashes);
+    for (const payload of payloads) {
+      if (!txPayloadHashes.has(payload._hash)) continue;
+      if (!isTransfer(payload)) continue;
+      if (payload.from !== bw.from) continue;
+      for (const [to, amount] of Object.entries(payload.transfers)) {
+        if (to === payload.from) continue;
+        outflow += hexToBigInt(amount ?? "00");
+      }
+    }
+    return outflow;
+  }
   // remove unfunded transactions and block transfers
   async filterByFunded(head, txs, transfers, validateBalances = false) {
     const fundedTransfers = [];
     const fundedTransactions = (await Promise.all(txs.map(async (tx) => {
       const transfer = transfers.find((transfer2) => transfer2.from === tx[0].from);
       if (!transfer) return;
-      const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
       if (validateBalances) {
-        const balance = (await this.accountBalanceViewer.accountBalances([
-          transfer.from
-        ]))[transfer.from] ?? AttoXL1(0n);
-        if (balance >= totalTransferCost) {
+        const totalOutflow = this.computeTransactionOutflow(tx);
+        const balance = (await this.accountBalanceViewer.accountBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n);
+        if (balance >= totalOutflow) {
           fundedTransfers.push(transfer);
           return tx;
         }
+        this.logger?.debug(
+          `filterByFunded: dropping tx ${tx[0]._hash} from ${transfer.from} \u2014 outflow ${totalOutflow} > balance ${balance}`
+        );
       } else {
         fundedTransfers.push(transfer);
         return tx;
       }
     }))).filter(exists);
-    return [
-      fundedTransactions,
-      fundedTransfers
-    ];
+    return [fundedTransactions, fundedTransfers];
   }
   async generateTimePayload() {
     return await this.timeSyncViewer.currentTimePayload();
   }
   /**
-  * Check if a heartbeat block is required based on network activity.
-  * @param head The current head block
-  * @returns True if a heartbeat is required, false otherwise
-  */
+   * Check if a heartbeat block is required based on network activity.
+   * @param head The current head block
+   * @returns True if a heartbeat is required, false otherwise
+   */
   heartbeatRequired(head) {
     const epoch = head.$epoch;
     if (isDefined2(epoch) && Date.now() - epoch > this.heartbeatInterval) {
@@ -729,50 +724,51 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
       await (dlq ? Promise.all(mismatched.map((tx) => dlq.rejectTransaction({
         schema: TransactionRejectionSchema,
         transaction: tx,
-        errors: [
-          {
-            hash: tx[0]._hash,
-            name: "TransactionChainMismatch",
-            message: `Transaction chain ${tx[0].chain} does not match local chain ${localChain}`
-          }
-        ],
+        errors: [{
+          hash: tx[0]._hash,
+          name: "TransactionChainMismatch",
+          message: `Transaction chain ${tx[0].chain} does not match local chain ${localChain}`
+        }],
         rejector: "producer"
       }))) : this.rejectedTransactionsArchivist.insert(mismatched.map((tx) => tx[0])));
     }
     return matched;
   }
   async runBuildValidateRetryLoop(args) {
-    const { chainId, head, initialFundedTransactions, initialFundedTransfers, nonTxPayloads, stepRewardPoolBalance, timePayload } = 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
-      ];
+      const blockPayloads = [...nonTxPayloads, ...candidateTransfers, timePayload];
       this.logger?.info(`Building block ${head.block + 1}${attempt > 0 ? ` (retry ${attempt})` : ""}`);
-      lastBlock = await buildNextBlock2(head, candidateTransactions, blockPayloads, [
-        this.account
-      ], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance, void 0, chainId);
-      const validated = await this.blockValidationViewer.validateBlock(lastBlock, {
-        head: head._hash
-      });
+      lastBlock = await buildNextBlock2(
+        head,
+        candidateTransactions,
+        blockPayloads,
+        [this.account],
+        XYO_STEP_REWARD_ADDRESS,
+        stepRewardPoolBalance,
+        void 0,
+        chainId
+      );
+      const validated = await this.blockValidationViewer.validateBlock(lastBlock, { head: head._hash });
       if (isSignedHydratedBlockWithHashMeta2(validated)) {
-        return {
-          block: validated,
-          errors: []
-        };
+        return { block: validated, errors: [] };
       }
       lastErrors = validated;
       if (attempt === maxAttempts) break;
-      const { offendingHashes, reason } = await identifyOffendingTransactions({
-        candidateTransactions,
-        errors: validated
-      });
+      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);
@@ -781,26 +777,28 @@ var SimpleBlockRunner = class _SimpleBlockRunner extends AbstractCreatableProvid
       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
-    };
+    return { block: lastBlock, errors: lastErrors };
   }
 };
-SimpleBlockRunner = _ts_decorate4([
+__publicField(SimpleBlockRunner, "defaultMoniker", BlockRunnerMoniker);
+__publicField(SimpleBlockRunner, "dependencies", [
+  AccountBalanceViewerMoniker,
+  BlockRewardViewerMoniker2,
+  BlockValidationViewerMoniker,
+  FinalizationViewerMoniker,
+  MempoolViewerMoniker,
+  TimeSyncViewerMoniker
+]);
+__publicField(SimpleBlockRunner, "monikers", [BlockRunnerMoniker]);
+SimpleBlockRunner = __decorateClass([
   creatableProvider3()
 ], SimpleBlockRunner);
 
 // src/StepStake/BaseStepStakeService.ts
 import { AbstractCreatableProvider as AbstractCreatableProvider5, StepStakeViewerMoniker } from "@xyo-network/xl1-sdk";
 var AbstractStepStakeService = class _AbstractStepStakeService extends AbstractCreatableProvider5 {
-  static {
-    __name(this, "AbstractStepStakeService");
-  }
   static defaultMoniker = StepStakeViewerMoniker;
-  static monikers = [
-    StepStakeViewerMoniker
-  ];
+  static monikers = [StepStakeViewerMoniker];
   moniker = _AbstractStepStakeService.defaultMoniker;
   stepStake(_step) {
     throw new Error("Method [stepStake] not implemented.");
@@ -822,4 +820,4 @@ export {
   createBootstrapHead,
   processPendingBlocks
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map