Examples with BeaconStateAltair tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair used on opensource projects

Example 1 with BeaconStateAltair

use of tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair in project teku by ConsenSys.

the class SyncCommitteeUtil method getSyncSubcommittees.

public Map<UInt64, SyncSubcommitteeAssignments> getSyncSubcommittees(final BeaconState state, final UInt64 epoch) {
    final UInt64 syncCommitteePeriod = computeSyncCommitteePeriod(epoch);
    final UInt64 currentEpoch = beaconStateAccessors.getCurrentEpoch(state);
    final UInt64 currentSyncCommitteePeriod = computeSyncCommitteePeriod(currentEpoch);
    checkArgument(isStateUsableForCommitteeCalculationAtEpoch(state, epoch), "State must be in the same or previous sync committee period. Cannot calculate epoch %s from state at slot %s", epoch, state.getSlot());
    final BeaconStateAltair altairState = BeaconStateAltair.required(state);
    return BeaconStateCache.getTransitionCaches(altairState).getSyncCommitteeCache().get(syncCommitteePeriod, period -> {
        final SyncCommittee syncCommittee;
        if (syncCommitteePeriod.equals(currentSyncCommitteePeriod)) {
            syncCommittee = altairState.getCurrentSyncCommittee();
        } else {
            syncCommittee = altairState.getNextSyncCommittee();
        }
        final int subcommitteeSize = getSubcommitteeSize();
        final SszVector<SszPublicKey> pubkeys = syncCommittee.getPubkeys();
        final Map<UInt64, SyncSubcommitteeAssignments.Builder> subcommitteeAssignments = new HashMap<>();
        for (int index = 0; index < pubkeys.size(); index++) {
            final BLSPublicKey pubkey = pubkeys.get(index).getBLSPublicKey();
            final UInt64 validatorIndex = UInt64.valueOf(validatorsUtil.getValidatorIndex(altairState, pubkey).orElseThrow(() -> new IllegalStateException("Unknown validator assigned to sync committee: " + pubkey)));
            final int subcommitteeIndex = index / subcommitteeSize;
            final int subcommitteeParticipationIndex = index - (subcommitteeIndex * subcommitteeSize);
            // Note we're using plain HashMap here instead of a concurrent alternative as they
            // are created once here and then never modified so safe to access from multiple
            // threads.
            subcommitteeAssignments.computeIfAbsent(validatorIndex, __ -> SyncSubcommitteeAssignments.builder()).addAssignment(subcommitteeIndex, subcommitteeParticipationIndex).addCommitteeIndex(index);
        }
        return subcommitteeAssignments.entrySet().stream().collect(toUnmodifiableMap(Map.Entry::getKey, entry -> entry.getValue().build()));
    });
}

Example 2 with BeaconStateAltair

use of tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair in project teku by ConsenSys.

the class EpochProcessorAltair method getRewardAndPenaltyDeltas.

@Override
public RewardAndPenaltyDeltas getRewardAndPenaltyDeltas(final BeaconState genericState, final ValidatorStatuses validatorStatuses) {
    final BeaconStateAltair state = BeaconStateAltair.required(genericState);
    final RewardsAndPenaltiesCalculatorAltair calculator = new RewardsAndPenaltiesCalculatorAltair(specConfigAltair, state, validatorStatuses, miscHelpersAltair, beaconStateAccessorsAltair);
    return calculator.getDeltas();
}

Example 3 with BeaconStateAltair

use of tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair in project teku by ConsenSys.

the class ValidatorStatusFactoryAltair method processParticipation.

@Override
protected void processParticipation(final List<ValidatorStatus> statuses, final BeaconState genericState, final UInt64 previousEpoch, final UInt64 currentEpoch) {
    final BeaconStateAltair state = BeaconStateAltair.required(genericState);
    final SszList<SszByte> previousParticipation = state.getPreviousEpochParticipation();
    final SszList<SszByte> currentParticipation = state.getCurrentEpochParticipation();
    for (int i = 0; i < statuses.size(); i++) {
        final ValidatorStatus status = statuses.get(i);
        if (status.isActiveInPreviousEpoch()) {
            final byte previousParticipationFlags = previousParticipation.get(i).get();
            if (miscHelpersAltair.hasFlag(previousParticipationFlags, ParticipationFlags.TIMELY_SOURCE_FLAG_INDEX)) {
                status.updatePreviousEpochSourceAttester(true);
            }
            if (miscHelpersAltair.hasFlag(previousParticipationFlags, ParticipationFlags.TIMELY_TARGET_FLAG_INDEX)) {
                status.updatePreviousEpochTargetAttester(true);
            }
            if (miscHelpersAltair.hasFlag(previousParticipationFlags, ParticipationFlags.TIMELY_HEAD_FLAG_INDEX)) {
                status.updatePreviousEpochHeadAttester(true);
            }
        }
        if (status.isActiveInCurrentEpoch()) {
            final byte currentParticipationFlags = currentParticipation.get(i).get();
            if (miscHelpersAltair.hasFlag(currentParticipationFlags, ParticipationFlags.TIMELY_SOURCE_FLAG_INDEX)) {
                status.updateCurrentEpochSourceAttester(true);
            }
            if (miscHelpersAltair.hasFlag(currentParticipationFlags, ParticipationFlags.TIMELY_TARGET_FLAG_INDEX)) {
                status.updateCurrentEpochTargetAttester(true);
            }
        }
    }
}

Example 4 with BeaconStateAltair

use of tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair in project teku by ConsenSys.

the class BellatrixStateUpgrade method upgrade.

@Override
public BeaconStateBellatrix upgrade(final BeaconState preState) {
    final UInt64 epoch = beaconStateAccessors.getCurrentEpoch(preState);
    BeaconStateAltair preStateAltair = BeaconStateAltair.required(preState);
    return schemaDefinitions.getBeaconStateSchema().createEmpty().updatedBellatrix(state -> {
        BeaconStateFields.copyCommonFieldsFromSource(state, preState);
        state.setCurrentEpochParticipation(preStateAltair.getCurrentEpochParticipation());
        state.setPreviousEpochParticipation(preStateAltair.getPreviousEpochParticipation());
        state.setCurrentSyncCommittee(preStateAltair.getCurrentSyncCommittee());
        state.setNextSyncCommittee(preStateAltair.getNextSyncCommittee());
        state.setInactivityScores(preStateAltair.getInactivityScores());
        state.setFork(new Fork(preState.getFork().getCurrent_version(), specConfig.getBellatrixForkVersion(), epoch));
        state.setLatestExecutionPayloadHeader(schemaDefinitions.getExecutionPayloadHeaderSchema().getDefault());
    });
}

Example 5 with BeaconStateAltair

use of tech.pegasys.teku.spec.datastructures.state.beaconstate.versions.altair.BeaconStateAltair in project teku by ConsenSys.

the class EpochProcessorAltairTest method processParticipationUpdates.

@Test
public void processParticipationUpdates() {
    final BeaconStateAltair randomState = generateRandomState();
    final int validatorCount = randomState.getValidators().size();
    final SszList<SszByte> currentEpochParticipationOrig = randomState.getCurrentEpochParticipation();
    final SszList<SszByte> previousEpochParticipationOrig = randomState.getPreviousEpochParticipation();
    final BeaconStateAltair updated = randomState.updatedAltair(epochProcessor::processParticipationUpdates);
    assertThat(updated.getPreviousEpochParticipation()).isNotEqualTo(previousEpochParticipationOrig);
    assertThat(updated.getPreviousEpochParticipation()).isEqualTo(currentEpochParticipationOrig);
    assertThat(updated.getCurrentEpochParticipation().size()).isEqualTo(validatorCount);
    for (int i = 0; i < validatorCount; i++) {
        assertThat(updated.getCurrentEpochParticipation().get(i).get()).isEqualTo((byte) 0);
    }
}