@xyo-network/chain-sdk 4.0.4 → 4.0.5

package/dist/neutral/services.mjs

@@ -0,0 +1,841 @@
+var __defProp = Object.defineProperty;
+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/modules/services/BlockReward/EvmBlockRewardViewer.ts
+import {
+  AbstractCreatable,
+  assertEx,
+  creatable,
+  toEthAddress
+} from "@ariestools/sdk";
+import { IXyoChainRewards__factory } from "@xyo-network/typechain";
+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");
+  }
+  get contractAddress() {
+    return assertEx(this._contractAddress, () => "contractAddress is required");
+  }
+  get provider() {
+    return assertEx(this.params.provider, () => "provider is required");
+  }
+  async allowedRewardForBlock(blockNumber) {
+    const contract = IXyoChainRewards__factory.connect(toEthAddress(this.contractAddress), this.provider);
+    return asAttoXL1(await contract.calcBlockReward(blockNumber));
+  }
+  async createHandler() {
+    await super.createHandler();
+    try {
+      this._contractAddress = await this.chainContractViewer.rewardsContract();
+    } catch (ex) {
+      const error = ex;
+      throw new Error(`Failed to get rewards contract address: ${error.message}`, { cause: ex });
+    }
+  }
+};
+__publicField(EvmBlockRewardViewer, "connectionTypes", ["evm-rpc"]);
+__publicField(EvmBlockRewardViewer, "defaultMoniker", BlockRewardViewerMoniker);
+__publicField(EvmBlockRewardViewer, "monikers", [BlockRewardViewerMoniker]);
+__publicField(EvmBlockRewardViewer, "surface", "node");
+EvmBlockRewardViewer = __decorateClass([
+  creatable()
+], EvmBlockRewardViewer);
+
+// src/modules/services/ChainValidator/XyoValidator.ts
+import { AbstractCreatableProvider, BlockViewerMoniker } from "@xyo-network/xl1-sdk";
+var XyoValidator = class extends AbstractCreatableProvider {
+  moniker = "Validator";
+  _blockViewer;
+  // get address() {
+  //   return this.account.address
+  // }
+  // protected get account() {
+  //   return assertEx(this.params.account, () => 'account is required')
+  // }
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  // protected get chainInfo() {
+  //   return assertEx(this.params.chainId, () => 'chainInfo is required')
+  // }
+  // protected get electionService() {
+  //   return assertEx(this.params.electionService, () => 'electionService is required')
+  // }
+  // protected get pendingBundledTransactionsArchivist() {
+  //   return assertEx(this.params.pendingBundledTransactionsArchivist, () => 'pendingBundledTransactions is required')
+  // }
+  // protected get blockRewardService() {
+  //   return assertEx(this.params.blockRewardService, () => 'blockRewardService is required')
+  // }
+  async createHandler() {
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
+  validatePendingBlock(_block) {
+    return [];
+  }
+  // TODO: Move to validator and inherit this class from validator
+  async validatePendingTransaction(hydratedTransaction) {
+    const [tx] = hydratedTransaction;
+    if (await this.blockViewer.blockByHash(tx._hash) !== void 0) return false;
+    return await Promise.resolve(true);
+  }
+};
+
+// src/modules/services/Election/BaseElectionService.ts
+import { assertEx as assertEx2 } from "@ariestools/sdk";
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider2,
+  creatableProvider
+} from "@xyo-network/xl1-sdk";
+import { hexToLast4BytesInt, shuffleWithSeed } from "#utils";
+var BaseElectionService = class extends AbstractCreatableProvider2 {
+  moniker = BaseElectionService.defaultMoniker;
+  get blockViewer() {
+    return assertEx2(this.params.blockViewer, () => "No block viewer");
+  }
+  get chainStakeViewer() {
+    return assertEx2(this.params.chainStakeViewer, () => "No chain stake viewer");
+  }
+  get stakeIntentService() {
+    return assertEx2(this.params.stakeIntentService, () => "No staked intent service");
+  }
+  async getCreatorCommitteeForNextBlock(current) {
+    return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
+      const nextBlock = current.block + 1;
+      const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, "producer");
+      const previousBlockHash = current._hash;
+      return this.generateCreatorCommittee(candidates, previousBlockHash);
+    }, this.context);
+  }
+  generateCreatorCommittee(candidates, previousBlockHash, maxSize = 3) {
+    const creators = new Set(candidates);
+    const seed = hexToLast4BytesInt(previousBlockHash);
+    const creatorArray = shuffleWithSeed(creators, seed);
+    return creatorArray.slice(0, maxSize);
+  }
+};
+__publicField(BaseElectionService, "defaultMoniker", "Election");
+__publicField(BaseElectionService, "dependencies", []);
+__publicField(BaseElectionService, "monikers", ["Election"]);
+BaseElectionService = __decorateClass([
+  creatableProvider()
+], BaseElectionService);
+
+// src/modules/services/implementation/head/createBootstrapHead.ts
+import { toAddress } from "@ariestools/sdk";
+import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
+import { buildNextBlock, createGenesisBlock } from "#protocol";
+var createBootstrapHead = async (account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
+  const chain = [];
+  const genesisBlock = await createGenesisBlock(account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress);
+  chain.push(genesisBlock);
+  const producerDeclarationPayload = createDeclarationIntent(
+    toAddress(account.address),
+    "producer",
+    genesisBlock[0].block,
+    genesisBlock[0].block + 1e4
+  );
+  const producerDeclarationBlock = await buildNextBlock(
+    genesisBlock[0],
+    [],
+    [producerDeclarationPayload],
+    [account]
+  );
+  chain.push(producerDeclarationBlock);
+  return chain;
+};
+
+// src/modules/services/implementation/processPendingBlocks.ts
+import { assertEx as assertEx3, isDefined } from "@ariestools/sdk";
+import { BlockRejectionSchema, isSignedHydratedBlockWithHashMeta } from "@xyo-network/xl1-sdk";
+import { ChainHeadSelector } from "#analyze";
+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({
+    context,
+    logger,
+    mempoolViewer,
+    blockViewer,
+    windowedFinalizedChain: [currentBlock],
+    allowedProducers,
+    minCandidates
+  });
+  const bestHeadChain = await headSelector.findBestHead();
+  if (isDefined(bestHeadChain) && bestHeadChain.length > 0) {
+    const oldHeadBlock = currentBlock[0];
+    const newHydratedHeadBlock = assertEx3(bestHeadChain.at(-1), () => "Missing best head block [processPendingBlocks]");
+    const newHeadBlock = newHydratedHeadBlock[0];
+    logger?.debug("Validating new HeadBlock head from (block) ", oldHeadBlock?.block, "to", newHeadBlock.block);
+    logger?.debug("Validating new HeadBlock head from (hash) ", oldHeadBlock?._hash, "to", newHeadBlock._hash);
+    if (newHeadBlock._hash === oldHeadBlock?._hash) {
+      logger?.debug("No new blocks found", oldHeadBlock?.block, "to", newHeadBlock.block);
+      return;
+    }
+    const candidateBlocks = bestHeadChain.filter((b) => {
+      return isDefined(oldHeadBlock) ? b[0].block > oldHeadBlock.block : true;
+    });
+    const validationResults = await Promise.all(candidateBlocks.map((candidateBlock) => Promise.resolve(blockValidationViewer.validateBlocks([candidateBlock], { value: true, state: true }))));
+    const blocksToFinalize = [];
+    for (const [i, block] of candidateBlocks.entries()) {
+      const result = validationResults[i][0];
+      if (isSignedHydratedBlockWithHashMeta(result)) {
+        blocksToFinalize.push(block);
+      } else {
+        logger?.error("Block validation failed", block[0].block, block[0]._hash, JSON.stringify(result, null, 2));
+        if (deadLetterQueueRunner) {
+          const errors = Array.isArray(result) ? result.map((e) => ({
+            hash: block[0]._hash,
+            name: "BlockValidationError",
+            message: String(e.message ?? e)
+          })) : [{ hash: block[0]._hash, name: "BlockValidationError" }];
+          await deadLetterQueueRunner.rejectBlock({
+            schema: BlockRejectionSchema,
+            block,
+            errors,
+            rejector: "validator"
+          });
+        }
+      }
+    }
+    logger?.info("Validated new HeadBlock head from (block) in", `${Date.now() - start}ms`, newHeadBlock.block, "to", oldHeadBlock?.block);
+    logger?.info("Validated new HeadBlock head from (hash) in", `${Date.now() - start}ms`, newHeadBlock._hash, "to", oldHeadBlock?._hash);
+    if (blocksToFinalize.length > 0) {
+      await finalizationRunner.finalizeBlocks(blocksToFinalize);
+    }
+    await headSelector.finalizeChainFragment(blocksToFinalize);
+    return blocksToFinalize;
+  }
+  logger?.info("No head found to validate", currentBlock?.[0]._hash);
+}
+
+// src/modules/services/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts
+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.");
+  }
+  networkStakeStepRewardAddressReward(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressReward] not implemented.");
+  }
+  networkStakeStepRewardAddressShare(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardAddressShare] not implemented.");
+  }
+  networkStakeStepRewardClaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardClaimedByAddress] not implemented.");
+  }
+  networkStakeStepRewardForPosition(_position, _range) {
+    throw new Error("Method [networkStakeStepRewardForPosition] not implemented.");
+  }
+  networkStakeStepRewardForStep(_context) {
+    throw new Error("Method [networkStakeStepRewardForStep] not implemented.");
+  }
+  networkStakeStepRewardForStepForPosition(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardForStepForPosition] not implemented.");
+  }
+  networkStakeStepRewardPoolRewards(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolRewards] not implemented.");
+  }
+  networkStakeStepRewardPoolShares(_context) {
+    throw new Error("Method [networkStakeStepRewardPoolShares] not implemented.");
+  }
+  networkStakeStepRewardPositionWeight(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPositionWeight] not implemented.");
+  }
+  networkStakeStepRewardPotentialPositionLoss(_context, _position) {
+    throw new Error("Method [networkStakeStepRewardPotentialPositionLoss] not implemented.");
+  }
+  networkStakeStepRewardRandomizer(_context) {
+    throw new Error("Method [networkStakeStepRewardRandomizer] not implemented.");
+  }
+  networkStakeStepRewardStakerCount(_context) {
+    throw new Error("Method [networkStakeStepRewardStakerCount] not implemented.");
+  }
+  networkStakeStepRewardUnclaimedByAddress(_address) {
+    throw new Error("Method [networkStakeStepRewardUnclaimedByAddress] not implemented.");
+  }
+  networkStakeStepRewardWeightForAddress(_context, _address) {
+    throw new Error("Method [networkStakeStepRewardWeightForAddress] not implemented.");
+  }
+  networkStakeStepRewardsForPosition(_position, _range) {
+    throw new Error("Method [networkStakeStepRewardsForPosition] not implemented.");
+  }
+  networkStakeStepRewardsForRange(_range) {
+    throw new Error("Method [networkStakeStepRewardsForRange] not implemented.");
+  }
+  networkStakeStepRewardsForStepLevel(_stepLevel, _range) {
+    throw new Error("Method [networkStakeStepRewardsForStepLevel] not implemented.");
+  }
+};
+__publicField(BaseNetworkStakeStepRewardService, "defaultMoniker", NetworkStakeStepRewardViewerMoniker);
+__publicField(BaseNetworkStakeStepRewardService, "dependencies", []);
+__publicField(BaseNetworkStakeStepRewardService, "monikers", [NetworkStakeStepRewardViewerMoniker]);
+BaseNetworkStakeStepRewardService = __decorateClass([
+  creatableProvider2()
+], BaseNetworkStakeStepRewardService);
+
+// src/modules/services/simple/block/runner/SimpleBlockRunner.ts
+import {
+  assertEx as assertEx5,
+  hexToBigInt,
+  isDefined as isDefined2,
+  toAddress as toAddress2
+} from "@ariestools/sdk";
+import {
+  MemoryArchivist,
+  PayloadBuilder as PayloadBuilder2
+} from "@xyo-network/sdk";
+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";
+import { FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema } from "#modules";
+import { buildNextBlock as buildNextBlock2 } from "#protocol";
+
+// src/modules/services/simple/block/runner/generateTransactionFeeTransfers.ts
+import { assertEx as assertEx4, hexFromBigInt } from "@ariestools/sdk";
+import { PayloadBuilder } from "@xyo-network/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])]);
+  }));
+  const txBaseFeeCosts = {};
+  for (const tx of txs) {
+    txBaseFeeCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + tx.fees.base;
+  }
+  const txGasCosts = {};
+  for (const tx of txs) {
+    const requiredGas = transactionRequiredGas(tx.data);
+    const totalGasCost = requiredGas * tx.fees.gasPrice;
+    txGasCosts[tx.boundWitness.from] = (txBaseFeeCosts[tx.boundWitness.from] ?? 0n) + totalGasCost;
+  }
+  const payloads = Object.entries(txBaseFeeCosts).map(([from, amount]) => {
+    const payload = {
+      schema: TransferSchema,
+      epoch: Date.now(),
+      from,
+      transfers: Object.fromEntries([[String(XYO_ZERO_ADDRESS), hexFromBigInt(amount)]])
+    };
+    return payload;
+  });
+  for (const [from, amount] of Object.entries(txGasCosts)) {
+    const fromPayload = assertEx4(payloads.find((p) => p.from === from), () => "from payload not found");
+    fromPayload.transfers[address] = hexFromBigInt(amount);
+  }
+  return payloads;
+}
+
+// src/modules/services/simple/block/runner/identifyOffendingTransactions.ts
+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 fromNet = netBalances[from] ?? 0n;
+  const transferOut = fromNet < 0n ? -fromNet : 0n;
+  return { cost: gasCost + baseCost + transferOut, gasPrice };
+}
+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" };
+}
+
+// src/modules/services/simple/block/runner/SimpleBlockRunner.ts
+var DEFAULT_BLOCK_SIZE = 10;
+var XYO_PRODUCER_REDECLARATION_DURATION = 100;
+var XYO_PRODUCER_REDECLARATION_WINDOW = 100;
+var SimpleBlockRunner = class extends AbstractCreatableProvider4 {
+  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;
+  _accountBalanceViewer;
+  _address;
+  _blockRewardViewer;
+  _blockValidationViewer;
+  _finalizationViewer;
+  _mempoolViewer;
+  _rewardAddress;
+  _timeSyncViewer;
+  /**
+   * 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
+   */
+  static get RedeclarationDuration() {
+    return XYO_PRODUCER_REDECLARATION_DURATION;
+  }
+  /**
+   * The number of blocks within which the producer will redeclare
+   * their intent to continue producing blocks
+   */
+  static get RedeclarationWindow() {
+    return XYO_PRODUCER_REDECLARATION_WINDOW;
+  }
+  get account() {
+    return this._account;
+  }
+  get accountBalanceViewer() {
+    return this._accountBalanceViewer;
+  }
+  get address() {
+    return this._address;
+  }
+  get blockRewardViewer() {
+    return this._blockRewardViewer;
+  }
+  get blockValidationViewer() {
+    return this._blockValidationViewer;
+  }
+  get finalizationViewer() {
+    return this._finalizationViewer;
+  }
+  get heartbeatInterval() {
+    return this.params.heartbeatInterval ?? 36e5;
+  }
+  get mempoolViewer() {
+    return this._mempoolViewer;
+  }
+  // protected get pendingTransactionsService() {
+  //   return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
+  // }
+  get rejectedTransactionsArchivist() {
+    return this._rejectedTransactionsArchivist;
+  }
+  get rewardAddress() {
+    return this._rewardAddress;
+  }
+  // protected get stakeIntentService(): StakeIntentService {
+  //   return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
+  // }
+  get timeSyncViewer() {
+    return this._timeSyncViewer;
+  }
+  // protected get validateHydratedBlockState() {
+  //   return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
+  // }
+  async createHandler() {
+    this._rejectedTransactionsArchivist = this.params.rejectedTransactionsArchivist ?? await MemoryArchivist.create();
+    this._account = assertEx5(this.params.account, () => "Account is required");
+    this._address = toAddress2(this.account.address);
+    this._accountBalanceViewer = await this.locateAndCreate(AccountBalanceViewerMoniker);
+    this._blockRewardViewer = await this.locateAndCreate(BlockRewardViewerMoniker2);
+    this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker);
+    this._finalizationViewer = await this.locateAndCreate(FinalizationViewerMoniker);
+    this._mempoolViewer = await this.locateAndCreate(MempoolViewerMoniker);
+    this._rewardAddress = this.params.rewardAddress;
+    this._timeSyncViewer = await this.locateAndCreate(TimeSyncViewerMoniker);
+    this._deadLetterQueueRunner = await this.locator.tryGetInstance(DeadLetterQueueRunnerMoniker);
+  }
+  async next(head) {
+    return await this.proposeNextValidBlock(head);
+  }
+  async produceNextBlock(head, force) {
+    const result = await this.proposeNextValidBlock(head);
+    return force === true ? assertEx5(result, () => "Failed to produce next block") : result;
+  }
+  async getBlockRewardTransfers(block) {
+    this._blockRewardDiviner ??= await FixedPercentageBlockRewardDiviner.create({
+      account: "random",
+      blockRewardViewer: this.blockRewardViewer,
+      config: {
+        rewardAddress: this.rewardAddress,
+        rewardPercentageRatio: defaultRewardRatio,
+        schema: FixedPercentageBlockRewardDivinerConfigSchema
+      }
+    });
+    const blockIdBuilder = new PayloadBuilder2({ schema: BlockNumberSchema });
+    const blockId = blockIdBuilder.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
+   */
+  getProducerRedeclaration(head) {
+    if (this.params.disableIntentRedeclaration === true) return;
+    const currentBlock = head.block;
+    if (isDefined2(this._lastRedeclarationBlock)) {
+      const lastDeclarationExpiry = this._lastRedeclarationBlock + SimpleBlockRunner.RedeclarationDuration;
+      if (currentBlock < lastDeclarationExpiry) return;
+    }
+    this._lastRedeclarationBlock = currentBlock;
+    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 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 nonTxPayloads = [];
+        const producerRedeclarationPayload = await this.getProducerRedeclaration(head);
+        if (producerRedeclarationPayload) nonTxPayloads.push(producerRedeclarationPayload);
+        if (nextBlockTransactions.length === 0 && !this.heartbeatRequired(head) && !force) return;
+        const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock);
+        nonTxPayloads.push(...rewardTransferPayloads);
+        const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions);
+        const timeStart = Date.now();
+        const timePayload = await this.generateTimePayload();
+        const timeDuration = Date.now() - timeStart;
+        if (timeDuration > 100) {
+          this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`);
+        }
+        const [initialFundedTransactions, initialFundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, shouldValidateBalances);
+        const stepRewardBalances = await this.accountBalanceViewer.accountBalances([XYO_STEP_REWARD_ADDRESS]);
+        const stepRewardPoolBalance = stepRewardBalances[String(XYO_STEP_REWARD_ADDRESS)];
+        const result = await this.runBuildValidateRetryLoop({
+          head,
+          chainId,
+          stepRewardPoolBalance,
+          nonTxPayloads,
+          timePayload,
+          initialFundedTransactions,
+          initialFundedTransfers
+        });
+        const { block: proposedBlock, errors: proposedErrors } = result;
+        if (isSignedHydratedBlockWithHashMeta2(proposedBlock)) {
+          return proposedBlock;
+        }
+        if (proposedBlock !== void 0) await this.rejectExhaustedBlock(proposedBlock, proposedErrors);
+      } catch (error) {
+        this.logger?.error(`Error proposing next valid block: ${error.message}`);
+        throw error;
+      }
+    }, 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.
+   */
+  addTransferOutflow(outflow, payload) {
+    let result = outflow;
+    for (const [to, amount] of Object.entries(payload.transfers)) {
+      if (to === payload.from) continue;
+      result += hexToBigInt(amount ?? "00");
+    }
+    return result;
+  }
+  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;
+      outflow = this.addTransferOutflow(outflow, payload);
+    }
+    return outflow;
+  }
+  // remove unfunded transactions and block transfers
+  async filterByFunded(head, txs, transfers, validateBalances = false) {
+    const fundedTransfers = [];
+    const fundedTransactions = [];
+    const committedOutflow = /* @__PURE__ */ new Map();
+    const balanceCache = /* @__PURE__ */ new Map();
+    for (const tx of txs) {
+      const transfer = transfers.find((candidate) => candidate.from === tx[0].from);
+      if (!transfer) continue;
+      if (!validateBalances) {
+        fundedTransfers.push(transfer);
+        fundedTransactions.push(tx);
+        continue;
+      }
+      const { from } = transfer;
+      let balance = balanceCache.get(from);
+      if (balance === void 0) {
+        const accountBalances = await this.accountBalanceViewer.accountBalances([from]);
+        balance = accountBalances[String(from)] ?? AttoXL1(0n);
+        balanceCache.set(from, balance);
+      }
+      const projectedOutflow = (committedOutflow.get(from) ?? 0n) + this.computeTransactionOutflow(tx);
+      if (balance >= projectedOutflow) {
+        committedOutflow.set(from, projectedOutflow);
+        fundedTransfers.push(transfer);
+        fundedTransactions.push(tx);
+      } else {
+        this.logger?.debug(
+          `filterByFunded: dropping tx ${tx[0]._hash} from ${from} \u2014 cumulative outflow ${projectedOutflow} > balance ${balance}`
+        );
+      }
+    }
+    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
+   */
+  heartbeatRequired(head) {
+    const epoch = head.$epoch;
+    if (isDefined2(epoch) && Date.now() - epoch > this.heartbeatInterval) {
+      return true;
+    }
+    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: BlockRejectionSchema2,
+        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();
+    const matched = [];
+    const mismatched = [];
+    for (const tx of transactions) {
+      if (tx[0].chain.toLowerCase() === localChain) {
+        matched.push(tx);
+      } else {
+        mismatched.push(tx);
+      }
+    }
+    if (mismatched.length > 0) {
+      this.logger?.warn(`Rejecting ${mismatched.length} transaction(s) targeting non-local chain`);
+      const dlq = this._deadLetterQueueRunner;
+      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}`
+        }],
+        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 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 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: [] };
+      }
+      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));
+      const feeTransfers = await generateTransactionFeeTransfers(this.address, candidateTransactions);
+      candidateTransfers = feeTransfers.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 };
+  }
+};
+__publicField(SimpleBlockRunner, "connectionTypes", ["lmdb", "mongo", "memory"]);
+__publicField(SimpleBlockRunner, "defaultMoniker", BlockRunnerMoniker);
+__publicField(SimpleBlockRunner, "dependencies", [
+  AccountBalanceViewerMoniker,
+  BlockRewardViewerMoniker2,
+  BlockValidationViewerMoniker,
+  FinalizationViewerMoniker,
+  MempoolViewerMoniker,
+  TimeSyncViewerMoniker
+]);
+__publicField(SimpleBlockRunner, "monikers", [BlockRunnerMoniker]);
+__publicField(SimpleBlockRunner, "surface", "node");
+SimpleBlockRunner = __decorateClass([
+  creatableProvider3()
+], SimpleBlockRunner);
+
+// src/modules/services/StepStake/BaseStepStakeService.ts
+import { AbstractCreatableProvider as AbstractCreatableProvider5, StepStakeViewerMoniker } from "@xyo-network/xl1-sdk";
+var AbstractStepStakeService = class _AbstractStepStakeService extends AbstractCreatableProvider5 {
+  static defaultMoniker = StepStakeViewerMoniker;
+  static monikers = [StepStakeViewerMoniker];
+  moniker = _AbstractStepStakeService.defaultMoniker;
+  stepStake(_step) {
+    throw new Error("Method [stepStake] not implemented.");
+  }
+  stepStakeForAddress(_address, _step) {
+    throw new Error("Method [stepStakeForAddress] not implemented.");
+  }
+};
+export {
+  AbstractStepStakeService,
+  BaseElectionService,
+  BaseNetworkStakeStepRewardService,
+  DEFAULT_BLOCK_SIZE,
+  EvmBlockRewardViewer,
+  SimpleBlockRunner,
+  XYO_PRODUCER_REDECLARATION_DURATION,
+  XYO_PRODUCER_REDECLARATION_WINDOW,
+  XyoValidator,
+  createBootstrapHead,
+  processPendingBlocks
+};
+//# sourceMappingURL=services.mjs.map