feat: index v0.1.34 settlement events

Support the consensus-breaking event-payload additions shipped in poktroll
v0.1.34 (pokt-network/poktroll#1952).

- New EventValidatorRewardDistribution entity + handler. Emitted once per
  bonded validator per op_reason per settlement block, it carries the
  canonical per-validator commission/delegator split. Build "VALIDATOR vs
  DELEGATOR" reward totals from this event rather than EventSettlementBatch:
  when a pokt address is both a validator account and a delegator on another
  validator, the bank-batch stream keys on (recipient, op_reason) and
  over-counts the validator side. Registered in EventHandlers and dispatched
  in indexRelays.

- Prefer chain-emitted num_estimated_relays (field 13) in the EventClaimCreated
  and EventClaimExpired paths via _computeNumEstimatedRelays. Removes the
  divide-by-zero the raw CUPR math hits when num_relays == 0; falls back to
  deriving from compute units for pre-upgrade blocks.

- Prefer chain-emitted supplier_stake_after_slash (EventSupplierSlashed
  field 9) for afterStakeAmount. Falls back to tracked stake minus penalty
  for pre-upgrade events; also robust when tracked stake drifts on pruned
  nodes.

All additions are backward-compatible: new fields are nullable/optional and
the handlers fall back to the prior derivation when a field is absent.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: oten91

schema.graphql

@@ -1131,6 +1131,52 @@ type EventProofValidityChecked @entity {
   event: Event!
 }
 
+# EventValidatorRewardDistribution is emitted once per bonded validator per
+# settlement op_reason per settlement block (v0.1.34+). It summarizes how that
+# validator's slice of the proposer reward pool was split into commission and
+# (self / external) delegator rewards. It is bounded by the validator-set size,
+# so it does NOT scale with delegators or claims (preserves the #1758 event-count
+# reduction).
+#
+# ACCOUNTING NOTE: build "VALIDATOR vs DELEGATOR" reward totals from THIS event
+# (per-validator) rather than from EventSettlementBatch / ModToAcctTransfer. When
+# the same pokt address is both a validator account AND a delegator on another
+# validator, the bank-batch stream buckets both incomes under the validator-side
+# op_reason, over-counting VALIDATOR and under-counting DELEGATOR. The split here
+# is unambiguous: commissionAmount is validator income; self/external delegator
+# amounts are delegator-side.
+#
+# All *Amount fields are denominated in upokt (chain emits bare integer strings).
+type EventValidatorRewardDistribution @entity {
+  id: ID!
+  # session_end_block_height of the FIRST claim in the batch. On the common
+  # single-session path this differs from the settlement block height only by the
+  # claim/proof window offsets; for a canonical timestamp use block.
+  sessionEndBlockHeight: BigInt!
+  # Distinguishes the Mint=Burn pool from the Global Mint pool.
+  opReason: SettlementOpReason!
+  # valoper... operator address.
+  validatorOperatorAddress: String! @index
+  # pokt... account address; commission + self-delegation slice are paid here.
+  validatorAccountAddress: String! @index
+  # Commission rate as a decimal string, e.g. "0.100000000000000000".
+  commissionRate: String!
+  # This validator's slice of the total proposer reward pool (upokt).
+  poolShareAmount: BigInt!
+  # Commission carved out of poolShareAmount, paid to the validator account (upokt).
+  commissionAmount: BigInt!
+  # Validator self-delegation slice of the post-commission remainder (upokt).
+  selfDelegationRewardAmount: BigInt!
+  # Portion of the post-commission remainder paid to external delegators (upokt).
+  delegatorsRewardAmount: BigInt!
+  # Total delegated stake backing this validator incl. self-delegation (upokt);
+  # the denominator for per-delegator reward attribution.
+  totalDelegatedStakeAmount: BigInt!
+  # Number of external (non-self) delegators that received a reward.
+  numDelegators: Int!
+  block: Block!
+}
+
 type Supply @entity {
   id: ID!
   denom: String! @index

src/mappings/handlers.ts

@@ -31,6 +31,7 @@ import {
   handleEventProofUpdated,
   handleEventProofValidityChecked,
   handleEventSettlementBatch,
+  handleEventValidatorRewardDistribution,
   handleMsgCreateClaim,
   handleMsgSubmitProof,
 } from "./pocket/relays";
@@ -126,6 +127,7 @@ export const EventHandlers: Record<string, (events: Array<CosmosEvent>) => Promi
   "pocket.tokenomics.EventApplicationOverserviced": handleEventApplicationOverserviced,
   "pocket.tokenomics.EventApplicationReimbursementRequest": handleEventApplicationReimbursementRequest,
   "pocket.tokenomics.EventSettlementBatch": handleEventSettlementBatch,
+  "pocket.tokenomics.EventValidatorRewardDistribution": handleEventValidatorRewardDistribution,
   "pocket.proof.EventClaimUpdated": handleEventClaimUpdated,
   "pocket.proof.EventProofUpdated": handleEventProofUpdated,
   "pocket.proof.EventProofValidityChecked": handleEventProofValidityChecked,

src/mappings/indexer.manager.ts

@@ -174,6 +174,7 @@ async function indexRelays(msgByType: MessageByType, eventByType: EventByType):
     "pocket.tokenomics.EventApplicationOverserviced",
     "pocket.tokenomics.EventApplicationReimbursementRequest",
     "pocket.tokenomics.EventSettlementBatch",
+    "pocket.tokenomics.EventValidatorRewardDistribution",
   ];
 
   await Promise.all([

src/mappings/pocket/relays.ts

@@ -20,6 +20,7 @@ import { EventClaimSettledProps } from "../../types/models/EventClaimSettled";
 import { EventClaimUpdatedProps } from "../../types/models/EventClaimUpdated";
 import { EventProofUpdatedProps } from "../../types/models/EventProofUpdated";
 import { EventProofValidityCheckedProps } from "../../types/models/EventProofValidityChecked";
+import { EventValidatorRewardDistributionProps } from "../../types/models/EventValidatorRewardDistribution";
 import { MsgCreateClaimProps } from "../../types/models/MsgCreateClaim";
 import { MsgSubmitProofProps } from "../../types/models/MsgSubmitProof";
 import { CoinSDKType } from "../../types/proto-interfaces/cosmos/base/v1beta1/coin";
@@ -232,7 +233,8 @@ export function getAttributes(attributes: CosmosEvent["event"]["attributes"]) {
     chainNumEstimatedRelays: bigint | undefined,
     mintedUpokt: CoinSDKType | undefined,
     overservicingLossUpokt: CoinSDKType | undefined,
-    deflationLossUpokt: CoinSDKType | undefined;
+    deflationLossUpokt: CoinSDKType | undefined,
+    supplierStakeAfterSlash: CoinSDKType | undefined;
 
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
@@ -341,6 +343,11 @@ export function getAttributes(attributes: CosmosEvent["event"]["attributes"]) {
       proofMissingPenalty = getDenomAndAmount(attribute.value as string);
     }
 
+    // EventSupplierSlashed field 9 (v0.1.34+): post-slash stake as a coin string.
+    if (attribute.key === "supplier_stake_after_slash") {
+      supplierStakeAfterSlash = getDenomAndAmount(attribute.value as string);
+    }
+
     if (attribute.key === "failure_reason") {
       failureReason = parseAttribute(attribute.value as string);
     }
@@ -414,6 +421,7 @@ export function getAttributes(attributes: CosmosEvent["event"]["attributes"]) {
     mintedUpokt,
     overservicingLossUpokt,
     deflationLossUpokt,
+    supplierStakeAfterSlash,
   };
 }
 
@@ -520,14 +528,20 @@ function _handleMsgCreateClaim(msg: CosmosMessage<MsgCreateClaim>): MsgCreateCla
    */
 
   const {
+    chainNumEstimatedRelays,
     claimed,
     numClaimedComputedUnits,
     numEstimatedComputedUnits,
     numRelays,
   } = getAttributes(eventClaimCreated.attributes);
 
-  const CUPR = Math.floor(Number(numClaimedComputedUnits) / Number(numRelays))
-  const numEstimatedRelays = BigInt(Math.round(Number(numEstimatedComputedUnits) / CUPR))
+  // Prefer the chain-emitted num_estimated_relays (EventClaimCreated field 13,
+  // v0.1.34+); fall back to deriving it from compute units for pre-upgrade blocks.
+  // The helper also avoids the divide-by-zero that the raw CUPR math hits when
+  // numRelays == 0.
+  const numEstimatedRelays = _computeNumEstimatedRelays(
+    chainNumEstimatedRelays, numEstimatedComputedUnits, numClaimedComputedUnits, numRelays,
+  );
 
   return {
     id: messageId(msg),
@@ -963,6 +977,7 @@ function _handleEventClaimSettled(
 
 function _handleEventClaimExpired(event: CosmosEvent): EventClaimExpiredProps {
   const {
+    chainNumEstimatedRelays,
     claim,
     claimed,
     expirationReason,
@@ -973,8 +988,12 @@ function _handleEventClaimExpired(event: CosmosEvent): EventClaimExpiredProps {
 
   const { proof_validation_status, session_header, supplier_operator_address } = claim;
 
-  const CUPR = Math.floor(Number(numClaimedComputedUnits) / Number(numRelays))
-  const numEstimatedRelays = BigInt(Math.round(Number(numEstimatedComputedUnits) / CUPR))
+  // Prefer the chain-emitted num_estimated_relays (EventClaimExpired field 13,
+  // v0.1.34+); fall back to deriving it for pre-upgrade blocks (also avoids the
+  // divide-by-zero in the raw CUPR math when numRelays == 0).
+  const numEstimatedRelays = _computeNumEstimatedRelays(
+    chainNumEstimatedRelays, numEstimatedComputedUnits, numClaimedComputedUnits, numRelays,
+  );
 
   return {
     supplierId: supplier_operator_address,
@@ -1576,3 +1595,90 @@ export async function handleEventSettlementBatch(events: Array<CosmosEvent>): Pr
     ]);
   }
 }
+
+// EventValidatorRewardDistribution (v0.1.34+) is emitted once per bonded
+// validator per settlement op_reason per settlement block. It carries the
+// canonical per-validator commission/delegator split, which is the correct
+// source for "VALIDATOR vs DELEGATOR" reward totals — see the entity comment in
+// schema.graphql for the cross-delegation accounting caveat that makes summing
+// from EventSettlementBatch alone over-count the validator side.
+function _handleEventValidatorRewardDistribution(event: CosmosEvent): EventValidatorRewardDistributionProps {
+  let sessionEndBlockHeight = BigInt(0),
+    opReason = "",
+    validatorOperatorAddress = "",
+    validatorAccountAddress = "",
+    commissionRate = "",
+    poolShareAmount = BigInt(0),
+    commissionAmount = BigInt(0),
+    selfDelegationRewardAmount = BigInt(0),
+    delegatorsRewardAmount = BigInt(0),
+    totalDelegatedStakeAmount = BigInt(0),
+    numDelegators = 0;
+
+  for (const attribute of event.event.attributes) {
+    switch (attribute.key) {
+      case "session_end_block_height":
+        sessionEndBlockHeight = BigInt(parseAttribute(attribute.value));
+        break;
+      case "op_reason":
+        opReason = parseAttribute(attribute.value);
+        break;
+      case "validator_operator_address":
+        validatorOperatorAddress = parseAttribute(attribute.value);
+        break;
+      case "validator_account_address":
+        validatorAccountAddress = parseAttribute(attribute.value);
+        break;
+      case "commission_rate":
+        commissionRate = parseAttribute(attribute.value);
+        break;
+      // *_upokt fields are emitted as bare integer strings (no denom).
+      case "pool_share_upokt":
+        poolShareAmount = BigInt(parseAttribute(attribute.value));
+        break;
+      case "commission_upokt":
+        commissionAmount = BigInt(parseAttribute(attribute.value));
+        break;
+      case "self_delegation_reward_upokt":
+        selfDelegationRewardAmount = BigInt(parseAttribute(attribute.value));
+        break;
+      case "delegators_reward_upokt":
+        delegatorsRewardAmount = BigInt(parseAttribute(attribute.value));
+        break;
+      case "total_delegated_stake_upokt":
+        totalDelegatedStakeAmount = BigInt(parseAttribute(attribute.value));
+        break;
+      case "num_delegators":
+        numDelegators = Number(parseAttribute(attribute.value));
+        break;
+      default:
+        break;
+    }
+  }
+
+  return {
+    // getEventId includes the event index, so per-validator/op_reason emissions
+    // within the same settlement block get distinct ids.
+    id: getEventId(event),
+    blockId: getBlockId(event.block),
+    sessionEndBlockHeight,
+    opReason: getSettlementOpReasonFromSDK(opReason),
+    validatorOperatorAddress,
+    validatorAccountAddress,
+    commissionRate,
+    poolShareAmount,
+    commissionAmount,
+    selfDelegationRewardAmount,
+    delegatorsRewardAmount,
+    totalDelegatedStakeAmount,
+    numDelegators,
+  };
+}
+
+export async function handleEventValidatorRewardDistribution(events: Array<CosmosEvent>): Promise<void> {
+  await optimizedBulkCreate(
+    "EventValidatorRewardDistribution",
+    events.map(_handleEventValidatorRewardDistribution),
+    "block_id",
+  );
+}

src/mappings/pocket/suppliers.ts

@@ -633,13 +633,16 @@ function _getValuesOldEventSupplierSlashed(event: CosmosEvent) {
     session: "",
     sessionStartHeight: BigInt(0),
     sessionEndHeight: BigInt(0),
+    // Not emitted before v0.1.34; afterStakeAmount is derived from stake - penalty.
+    supplierStakeAfterSlash: undefined as CoinSDKType | undefined,
   }
 }
 
 function _getValuesEventSupplierSlashed(event: CosmosEvent) {
   const {
     claim,
     proofMissingPenalty,
+    supplierStakeAfterSlash,
   } = getAttributes(event.event.attributes);
 
   if (!claim || !claim.session_header || Object.keys(claim).length === 0) {
@@ -656,6 +659,7 @@ function _getValuesEventSupplierSlashed(event: CosmosEvent) {
     sessionStartHeight: BigInt(claim.session_header.session_start_block_height || "0"),
     proofMissingPenalty,
     proofValidationStatus: getClaimProofStatusFromSDK(claim.proof_validation_status),
+    supplierStakeAfterSlash,
   }
 }
 
@@ -678,6 +682,7 @@ export function _handleEventSupplierSlashed(
     session,
     sessionEndHeight,
     sessionStartHeight,
+    supplierStakeAfterSlash,
   } = _getValuesEventSupplierSlashed(event);
 
   if (!operatorAddress) {
@@ -695,7 +700,12 @@ export function _handleEventSupplierSlashed(
   }
 
   const previousStakeAmount = currentSupplier.stakeAmount.valueOf();
-  const afterStakeAmount = currentSupplier.stakeAmount - BigInt(proofMissingPenalty.amount);
+  // Prefer the chain-emitted post-slash stake (supplier_stake_after_slash, v0.1.34+);
+  // fall back to deriving it from the indexer-tracked stake minus the penalty for
+  // pre-upgrade events (also robust when tracked stake drifts on pruned nodes).
+  const afterStakeAmount = supplierStakeAfterSlash
+    ? BigInt(supplierStakeAfterSlash.amount)
+    : currentSupplier.stakeAmount - BigInt(proofMissingPenalty.amount);
 
   return {
     supplier: {