@lodestar/state-transition 1.39.0-dev.b6bba4cb8c → 1.39.0-dev.b6d377a93c

package/src/rewards/blockRewards.ts

@@ -0,0 +1,147 @@
+import {BeaconConfig} from "@lodestar/config";
+import {
+  ForkName,
+  WHISTLEBLOWER_REWARD_QUOTIENT,
+  WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {BeaconBlock, altair, phase0, rewards} from "@lodestar/types";
+import {processAttestationsAltair} from "../block/processAttestationsAltair.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../cache/stateCache.js";
+import {getAttesterSlashableIndices} from "../util/attestation.js";
+
+type SubRewardValue = number; // All reward values should be integer
+
+/**
+ * Calculate total proposer block rewards given block and the beacon state of the same slot before the block is applied (preState)
+ * postState can be passed in to read reward cache if available
+ * Standard (Non MEV) rewards for proposing a block consists of:
+ *  1) Including attestations from (beacon) committee
+ *  2) Including attestations from sync committee
+ *  3) Reporting slashable behaviours from proposer and attester
+ */
+export async function computeBlockRewards(
+  config: BeaconConfig,
+  block: BeaconBlock,
+  preState: CachedBeaconStateAllForks,
+  postState?: CachedBeaconStateAllForks
+): Promise<rewards.BlockRewards> {
+  const fork = config.getForkName(block.slot);
+  const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
+    postState?.proposerRewards ?? {};
+  let blockAttestationReward = cachedAttestationsReward;
+  let syncAggregateReward = cachedSyncAggregateReward;
+
+  if (blockAttestationReward === 0) {
+    blockAttestationReward =
+      fork === ForkName.phase0
+        ? computeBlockAttestationRewardPhase0(block as phase0.BeaconBlock, preState as CachedBeaconStatePhase0)
+        : computeBlockAttestationRewardAltair(config, block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
+  }
+
+  if (syncAggregateReward === 0) {
+    syncAggregateReward = computeSyncAggregateReward(block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
+  }
+
+  const blockProposerSlashingReward = computeBlockProposerSlashingReward(fork, block, preState);
+  const blockAttesterSlashingReward = computeBlockAttesterSlashingReward(fork, block, preState);
+
+  const total =
+    blockAttestationReward + syncAggregateReward + blockProposerSlashingReward + blockAttesterSlashingReward;
+
+  return {
+    proposerIndex: block.proposerIndex,
+    total,
+    attestations: blockAttestationReward,
+    syncAggregate: syncAggregateReward,
+    proposerSlashings: blockProposerSlashingReward,
+    attesterSlashings: blockAttesterSlashingReward,
+  };
+}
+
+/**
+ * TODO: Calculate rewards received by block proposer for including attestations.
+ */
+function computeBlockAttestationRewardPhase0(
+  _block: phase0.BeaconBlock,
+  _preState: CachedBeaconStatePhase0
+): SubRewardValue {
+  throw new Error("Unsupported fork! Block attestation reward calculation is not available in phase0");
+}
+
+/**
+ * Calculate rewards received by block proposer for including attestations since Altair.
+ * Reuses `processAttestationsAltair()`. Has dependency on RewardCache
+ */
+function computeBlockAttestationRewardAltair(
+  config: BeaconConfig,
+  block: altair.BeaconBlock,
+  preState: CachedBeaconStateAltair
+): SubRewardValue {
+  const fork = config.getForkSeq(block.slot);
+  const {attestations} = block.body;
+
+  processAttestationsAltair(fork, preState, attestations, false);
+
+  return preState.proposerRewards.attestations;
+}
+
+function computeSyncAggregateReward(block: altair.BeaconBlock, preState: CachedBeaconStateAltair): SubRewardValue {
+  if (block.body.syncAggregate !== undefined) {
+    const {syncCommitteeBits} = block.body.syncAggregate;
+    const {syncProposerReward} = preState.epochCtx;
+
+    return syncCommitteeBits.getTrueBitIndexes().length * Math.floor(syncProposerReward); // syncProposerReward should already be integer
+  }
+
+  return 0; // phase0 block does not have syncAggregate
+}
+
+/**
+ * Calculate rewards received by block proposer for including proposer slashings.
+ * All proposer slashing rewards go to block proposer and none to whistleblower as of Deneb
+ */
+function computeBlockProposerSlashingReward(
+  fork: ForkName,
+  block: BeaconBlock,
+  state: CachedBeaconStateAllForks
+): SubRewardValue {
+  let proposerSlashingReward = 0;
+
+  for (const proposerSlashing of block.body.proposerSlashings) {
+    const offendingProposerIndex = proposerSlashing.signedHeader1.message.proposerIndex;
+    const offendingProposerBalance = state.validators.getReadonly(offendingProposerIndex).effectiveBalance;
+    const whistleblowerRewardQuotient = isForkPostElectra(fork)
+      ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
+      : WHISTLEBLOWER_REWARD_QUOTIENT;
+
+    proposerSlashingReward += Math.floor(offendingProposerBalance / whistleblowerRewardQuotient);
+  }
+
+  return proposerSlashingReward;
+}
+
+/**
+ * Calculate rewards received by block proposer for including attester slashings.
+ * All attester slashing rewards go to block proposer and none to whistleblower as of Deneb
+ */
+function computeBlockAttesterSlashingReward(
+  fork: ForkName,
+  block: BeaconBlock,
+  preState: CachedBeaconStateAllForks
+): SubRewardValue {
+  let attesterSlashingReward = 0;
+
+  for (const attesterSlashing of block.body.attesterSlashings) {
+    for (const offendingAttesterIndex of getAttesterSlashableIndices(attesterSlashing)) {
+      const offendingAttesterBalance = preState.validators.getReadonly(offendingAttesterIndex).effectiveBalance;
+      const whistleblowerRewardQuotient = isForkPostElectra(fork)
+        ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
+        : WHISTLEBLOWER_REWARD_QUOTIENT;
+
+      attesterSlashingReward += Math.floor(offendingAttesterBalance / whistleblowerRewardQuotient);
+    }
+  }
+
+  return attesterSlashingReward;
+}

package/src/rewards/index.ts

@@ -0,0 +1,3 @@
+export * from "./attestationsRewards.js";
+export * from "./blockRewards.js";
+export * from "./syncCommitteeRewards.js";

package/src/rewards/syncCommitteeRewards.ts

@@ -0,0 +1,59 @@
+import {BeaconConfig} from "@lodestar/config";
+import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
+import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
+
+type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
+
+export async function computeSyncCommitteeRewards(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
+  block: BeaconBlock,
+  preState: CachedBeaconStateAllForks,
+  validatorIds: (ValidatorIndex | string)[] = []
+): Promise<rewards.SyncCommitteeRewards> {
+  const fork = config.getForkName(block.slot);
+  if (fork === ForkName.phase0) {
+    throw Error("Cannot get sync rewards as phase0 block does not have sync committee");
+  }
+
+  const altairBlock = block as altair.BeaconBlock;
+  const preStateAltair = preState as CachedBeaconStateAltair;
+
+  // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
+  const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(
+    0,
+    SYNC_COMMITTEE_SIZE
+  );
+  const {syncParticipantReward} = preStateAltair.epochCtx;
+  const {syncCommitteeBits} = altairBlock.body.syncAggregate;
+
+  // Use balance of each committee as starting point such that we cap the penalty to avoid balance dropping below 0
+  const balances: Map<ValidatorIndex, BalanceRecord> = new Map();
+  for (const i of syncCommitteeValidatorIndices) {
+    balances.set(i, {val: preStateAltair.balances.get(i)});
+  }
+
+  for (const i of syncCommitteeValidatorIndices) {
+    const balanceRecord = balances.get(i) as BalanceRecord;
+    if (syncCommitteeBits.get(i)) {
+      // Positive rewards for participants
+      balanceRecord.val += syncParticipantReward;
+    } else {
+      // Negative rewards for non participants
+      balanceRecord.val = Math.max(0, balanceRecord.val - syncParticipantReward);
+    }
+  }
+
+  const rewards = Array.from(balances, ([validatorIndex, v]) => ({validatorIndex, reward: v.val}));
+
+  if (validatorIds.length) {
+    const filtersSet = new Set(validatorIds);
+    return rewards.filter(
+      (reward) => filtersSet.has(reward.validatorIndex) || filtersSet.has(index2pubkey[reward.validatorIndex].toHex())
+    );
+  }
+
+  return rewards;
+}

package/src/signatureSets/proposer.ts

@@ -2,7 +2,6 @@ import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
@@ -38,28 +37,28 @@ export function getBlockProposerSignatureSet(
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  parentState: CachedBeaconStateAllForks,
+  parentStateSlot: Slot,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, parentStateSlot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {