예제 #1
0
    def update_proposer(self, current_state):
        # This is a fairly expensive operation, so we try not to call it when we don't have to.
        # Update proposer duties for the current epoch.
        # We need to check for each slot of the epoch whether the validator is a proposer or not.

        current_epoch = specs.get_current_epoch(current_state)

        start_slot = specs.compute_start_slot_at_epoch(current_epoch)

        start_state = current_state.copy() if start_slot == current_state.slot else \
        self.store.block_states[specs.get_block_root(current_state, current_epoch)].copy()

        current_proposer_duties = []
        for slot in range(start_slot, start_slot + specs.SLOTS_PER_EPOCH):
            if slot < start_state.slot:
                current_proposer_duties += [False]
                continue

            if start_state.slot < slot:
                specs.process_slots(start_state, slot)

            current_proposer_duties += [
                specs.get_beacon_proposer_index(start_state) ==
                self.validator_index
            ]

        self.data.current_proposer_duties = current_proposer_duties
예제 #2
0
파일: brlib.py 프로젝트: rogervs/rig
def disseminate_blocks(params, step, sL, s, _input):
    start = time.time()

    network = s["network"]
    for info_set_index, blocks in enumerate(_input["blocks"]):
        state = network.sets[info_set_index].beacon_state
        for block in blocks:
            if block is None:
                continue
            specs.process_block(state, block.message)

        # process_slots is the bottleneck in terms of speed
        specs.process_slots(state, state.slot + 1)

    network.attestations = [
        item for item_index, item in enumerate(network.attestations)
        if item_index not in _input["attestation_indices"]
    ]

    if log:
        print("removing", len(_input["attestation_indices"]),
              "from network items, there are now", len(network.attestations),
              "items")

    if log: print("disseminate_blocks time = ", time.time() - start)

    return ('network', network)
예제 #3
0
    def process_to_slot(self, current_state_root, slot):
        # Our cached `process_slots` operation

        # If we want to fast-forward a state root to some slot, we check if we have already recorded the
        # resulting state.
        if (current_state_root, slot) in BRValidator.state_store:
            return BRValidator.state_store[(current_state_root, slot)].copy()

        # If we haven't, we need to process it.
        else:
            current_state = self.store.block_states[current_state_root].copy()
            if current_state.slot < slot:
                specs.process_slots(current_state, slot)
            BRValidator.state_store[(current_state_root, slot)] = current_state
            return current_state.copy()
예제 #4
0
파일: validatorlib.py 프로젝트: rogervs/rig
def honest_attest(validator, known_items):

    # Unpacking
    validator_index = validator.validator_index
    store = validator.store
    committee_slot = validator.data.current_attest_slot
    committee_index = validator.data.current_committee_index
    committee = validator.data.current_committee

    # What am I attesting for?
    block_root = validator.get_head()
    head_state = store.block_states[block_root].copy()
    if head_state.slot < committee_slot:
        specs.process_slots(head_state, committee_slot)
    start_slot = specs.compute_start_slot_at_epoch(
        specs.get_current_epoch(head_state))
    epoch_boundary_block_root = block_root if start_slot == head_state.slot else specs.get_block_root_at_slot(
        head_state, start_slot)
    tgt_checkpoint = specs.Checkpoint(
        epoch=specs.get_current_epoch(head_state),
        root=epoch_boundary_block_root)

    att_data = specs.AttestationData(
        index=committee_index,
        slot=committee_slot,
        beacon_block_root=block_root,
        source=head_state.current_justified_checkpoint,
        target=tgt_checkpoint)

    # Set aggregation bits to myself only
    committee_size = len(committee)
    index_in_committee = committee.index(validator_index)
    aggregation_bits = Bitlist[specs.MAX_VALIDATORS_PER_COMMITTEE](
        *([0] * committee_size))
    aggregation_bits[
        index_in_committee] = True  # set the aggregation bit of the validator to True
    attestation = specs.Attestation(aggregation_bits=aggregation_bits,
                                    data=att_data)

    #     print(validator.validator_index, "attests for slot", committee_slot)

    return attestation
예제 #5
0
def transition_state(params, step, sL, s, _input):
    # Transition from w-[s] to w-[s+1]

    # `state` is w-[s]
    state = s['beacon_state']

    # We get the block from the policy `propose_block`.
    new_block = _input['block']

    # `state_transition` calls `process_slots` before `process_block`.
    # Effectively `process_slots` does not do anything here: it would move us from
    # w+[s-1] to w-[s]. `process_block` takes us from w-[s] to w+[s].
    post_state = state_transition(state=state,
                                  signed_block=new_block,
                                  validate_result=False)

    # We call `process_slots` to go from w+[s] to w-[s+1]
    process_slots(post_state, post_state.slot + 1)

    print("now at state w-[", post_state.slot, "]")
    return ('beacon_state', post_state)
예제 #6
0
    def __init__(self, state, validator_index):
        # Validator constructor
        # We preload a bunch of things, to be updated later on as needed
        # The validator is initialised from some base state, and given a `validator_index`
        self.validator_index = validator_index

        self.store = specs.get_forkchoice_store(state)
        self.history = []

        self.data = ValidatorData()
        self.data.time_ms = self.store.time * 1000
        self.data.recorded_attestations = []

        self.data.slot = specs.get_current_slot(self.store)
        self.data.current_epoch = specs.compute_epoch_at_slot(self.data.slot)

        self.data.head_root = self.get_head()
        current_state = state.copy()
        if current_state.slot < self.data.slot:
            specs.process_slots(current_state, self.data.slot)

        self.update_attester(current_state, self.data.current_epoch)
        self.update_proposer(current_state)
        self.update_data()