深度丨以太坊 2.0 Staking 硬核四问

    mkdir prysm && cd prysm   curl https://raw.githubusercontent.com/prysmaticlabs/prysm/master/prysm.sh --output prysm.sh && chmod +x prysm.sh

    ./prysm.sh beacon-chain./prysm.sh validator

      @public    def deposit(pubkey: bytes[PUBKEY_LENGTH],                withdrawal_credentials: bytes[WITHDRAWAL_CREDENTIALS_LENGTH],                signature: bytes[SIGNATURE_LENGTH],                deposit_data_root: bytes32):            ############## 1. 参数基础校验 ################        # Avoid overflowing the Merkle tree (and prevent edge case in computing `self.branch`)        assert self.deposit_count < MAX_DEPOSIT_COUNT            # Check deposit amount        deposit_amount: uint256 = msg.value / as_wei_value(1, "gwei")        assert deposit_amount >= MIN_DEPOSIT_AMOUNT            # Length checks for safety        assert len(pubkey) == PUBKEY_LENGTH        assert len(withdrawal_credentials) == WITHDRAWAL_CREDENTIALS_LENGTH        assert len(signature) == SIGNATURE_LENGTH        #########################################            # Emit `DepositEvent` log        amount: bytes[8] = self.to_little_endian_64(deposit_amount)                    ############## 2. 触发存款事件 ################        log.DepositEvent(pubkey, withdrawal_credentials, amount, signature, self.to_little_endian_64(self.deposit_count))                    ############## 3. 校验数据完整性 ################        # Compute deposit data root (`DepositData` hash tree root)        zero_bytes32: bytes32 = 0x0000000000000000000000000000000000000000000000000000000000000000        pubkey_root: bytes32 = sha256(concat(pubkey, slice(zero_bytes32, start=0, len=64 - PUBKEY_LENGTH)))        signature_root: bytes32 = sha256(concat(            sha256(slice(signature, start=0, len=64)),            sha256(concat(slice(signature, start=64, len=SIGNATURE_LENGTH - 64), zero_bytes32)),        ))        node: bytes32 = sha256(concat(            sha256(concat(pubkey_root, withdrawal_credentials)),            sha256(concat(amount, slice(zero_bytes32, start=0, len=32 - AMOUNT_LENGTH), signature_root)),        ))        # Verify computed and expected deposit data roots match        assert node == deposit_data_root        ###########################################                    ############## 4. 更新 Merkle Tree ################        # Add deposit data root to Merkle tree (update a single `branch` node)        self.deposit_count += 1        size: uint256 = self.deposit_count        for height in range(DEPOSIT_CONTRACT_TREE_DEPTH):            if bitwise_and(size, 1) == 1:  # More gas efficient than `size % 2 == 1`                self.branch[height] = node                break            node = sha256(concat(self.branch[height], node))            size /= 2 

      def process_deposit(state: BeaconState, deposit: Deposit) -> None:            ##################### 必要检验 ###################        # Verify the Merkle branch        assert is_valid_merkle_branch(            leaf=hash_tree_root(deposit.data),            branch=deposit.proof,            depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in            index=state.eth1_deposit_index,            root=state.eth1_data.deposit_root,        )            # Deposits must be processed in order        state.eth1_deposit_index += 1            pubkey = deposit.data.pubkey        amount = deposit.data.amount        validator_pubkeys = [v.pubkey for v in state.validators]        if pubkey not in validator_pubkeys:            # Verify the deposit signature (proof of possession) which is not checked by the deposit contract            deposit_message = DepositMessage(                pubkey=deposit.data.pubkey,                withdrawal_credentials=deposit.data.withdrawal_credentials,                amount=deposit.data.amount,            )            domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks            signing_root = compute_signing_root(deposit_message, domain)            if not bls.Verify(pubkey, signing_root, deposit.data.signature):                return        #################################################                ##################### 添加新验证人 ###################            # Add validator and balance entries            state.validators.append(get_validator_from_deposit(state, deposit))            state.balances.append(amount)        #################################################        else:            ################ 同一个验证人多次存入 ###############            # Increase balance by deposit amount            index = ValidatorIndex(validator_pubkeys.index(pubkey))            increase_balance(state, index, amount)        ################################################# 

    def get_validator_from_deposit(state: BeaconState, deposit: Deposit) -> Validator:      amount = deposit.data.amount    
        # 设置有效余额      effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)    
        # 设置验证者信息和生命周期相关参数      return Validator(          pubkey=deposit.data.pubkey,          withdrawal_credentials=deposit.data.withdrawal_credentials,          activation_eligibility_epoch=FAR_FUTURE_EPOCH,          activation_epoch=FAR_FUTURE_EPOCH,          exit_epoch=FAR_FUTURE_EPOCH,          withdrawable_epoch=FAR_FUTURE_EPOCH,          effective_balance=effective_balance,        )  

      def process_registry_updates(state: BeaconState) -> None:        # Process activation eligibility and ejections        for index, validator in enumerate(state.validators):                # 可否进入等待队列            if is_eligible_for_activation_queue(validator):                validator.activation_eligibility_epoch = get_current_epoch(state) + 1                # 可否成为活跃的验证者            if is_active_validator(validator, get_current_epoch(state)) and validator.effective_balance <= EJECTION_BALANCE:                initiate_validator_exit(state, ValidatorIndex(index))            # 限制每周期成为验证者数量        # Queue validators eligible for activation and not yet dequeued for activation  15.      activation_queue = sorted([            index for index, validator in enumerate(state.validators)            if is_eligible_for_activation(state, validator)            # Order by the sequence of activation_eligibility_epoch setting and then index        ], key=lambda index: (state.validators[index].activation_eligibility_epoch, index))        # Dequeued validators for activation up to churn limit        for index in activation_queue[:get_validator_churn_limit(state)]:            validator = state.validators[index]            validator.activation_epoch = compute_activation_exit_epoch(get_current_epoch(state)) 

       *

          [m / 0] - [m / 0 / 0]     /        \    /           [m / 0 / 1][m] - [m / 1]    \     ...      [m / i]

    def get_attestation_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:      """     Return attestation reward/penalty deltas for each validator.     """      source_rewards, source_penalties = get_source_deltas(state)  # 计算检查点 source 奖惩      target_rewards, target_penalties = get_target_deltas(state)  # 计算检查点 target 奖惩      head_rewards, head_penalties = get_head_deltas(state)  # 计算最新区块奖惩      inclusion_delay_rewards,_= get_inclusion_delay_deltas(state)  # 计算入块延迟奖惩     _, inactivity_penalties = get_inactivity_penalty_deltas(state)    
        rewards = [          source_rewards[i] + target_rewards[i] + head_rewards[i] + inclusion_delay_rewards[i]          for i in range(len(state.validators))      ]    
        penalties = [          source_penalties[i] + target_penalties[i] + head_penalties[i] + inactivity_penalties[i]          for i in range(len(state.validators))      ]    
        return rewards, penalties

                               *

    def get_attestation_component_deltas(state: BeaconState,                                       attestations: Sequence[PendingAttestation]                                       ) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:      """     Helper with shared logic for use by get source, target, and head deltas functions     """      rewards = [Gwei(0)] * len(state.validators)      penalties = [Gwei(0)] * len(state.validators)      total_balance = get_total_active_balance(state)      unslashed_attesting_indices = get_unslashed_attesting_indices(state, attestations)      attesting_balance = get_total_balance(state, unslashed_attesting_indices)      for index in get_eligible_validator_indices(state):          if index in unslashed_attesting_indices:              increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from balance totals to avoid uint64 overflow              if is_in_inactivity_leak(state):                  # Since full base reward will be canceled out by inactivity penalty deltas,                  # optimal participation receives full base reward compensation here.                  rewards[index] += get_base_reward(state, index)              else:                  reward_numerator = get_base_reward(state, index) * (attesting_balance // increment)                  rewards[index] += reward_numerator // (total_balance // increment)          else:              penalties[index] += get_base_reward(state, index) 

    reward_numerator = get_base_reward(state, index) * (attesting_balance // increment)   rewards[index] += reward_numerator // (total_balance // increment)  

    def get_base_reward(state: BeaconState, index: ValidatorIndex) -> Gwei:      total_balance = get_total_active_balance(state)      effective_balance = state.validators[index].effective_balance      return Gwei(effective_balance * BASE_REWARD_FACTOR // integer_squareroot(total_balance) // BASE_REWARDS_PER_EPOCH)      # BASE_REWARD_FACTOR = 64 基础奖励倍数      # BASE_REWARDS_PER_EPOCH = 4 每个 Epoch 的基础奖励      # effective_balance 验证人的有效余额      # integer_squareroot(total_balance) 所有有效余额的开平方

    def get_proposer_reward(state: BeaconState, attesting_index: ValidatorIndex) -> Gwei:    return Gwei(get_base_reward(state, attesting_index) // PROPOSER_REWARD_QUOTIENT)