Disputes (ψ)

Bases: StateComponent

Source code in pyjamaz/state/components.py

class Disputes(StateComponent):
    component_id = 5

    @log_execution_time
    def state_transition(
            self,
            extrinsic_disputes: ExtrinsicDisputes,
            pre_state_disputes: DisputesState
    ) -> DisputesOutput:
        """
        GP-0.7.2-eq:10.16,10.17,10.18,10.19 (ψ') | State transition function for the state's disputes.

        Parameters
        ----------
        extrinsic_disputes: ExtrinsicDisputes
            GP-0.7.2-eq:4.11 (bold_E_D)
        pre_state_disputes: DisputesState
            GP-0.7.2-eq:4.11 (ψ)

        Returns
        -------
        DisputesOutput
            Output containing: Posterior state of DisputesState (ψ')
        """

        self.output = DisputesOutput(
            post_state=deepcopy(pre_state_disputes), offenders_mark=[]
        )

        if not self.are_faults_verdict_correct(extrinsic_disputes.faults):
            raise StateTransitionError(DisputesErrorCode.fault_verdict_wrong)

        # GP-0.7.2-eq:10.2 | Check if all culprits have valid signatures
        if not all(c.has_valid_signature() for c in extrinsic_disputes.culprits):
            raise StateTransitionError(DisputesErrorCode.bad_signature)

        # GP-0.7.2-eq:10.2 | Check if all faults have valid signatures
        if not all(f.has_valid_signature() for f in extrinsic_disputes.faults):
            raise StateTransitionError(DisputesErrorCode.bad_signature)

        # GP-0.7.2-eq:10.7 | Check if verdicts are sorted
        if not self.are_verdicts_sorted(extrinsic_disputes.verdicts):
            raise StateTransitionError(DisputesErrorCode.verdicts_not_sorted_unique)

        if self.has_duplicate_report_hashes(extrinsic_disputes.verdicts):
            raise StateTransitionError(DisputesErrorCode.verdicts_not_sorted_unique)

        # TODO: add reference to GP equations
        # Process verdicts
        for verdict in extrinsic_disputes.verdicts:

            if self.is_already_judged(verdict):
                raise StateTransitionError(DisputesErrorCode.already_judged)

            # GP-0.7.2-eq:10.10 | Check if judgements are sorted and unique
            if not self.are_judgements_sorted(verdict.votes) or self.has_duplicate_judgements(verdict.votes):
                raise StateTransitionError(DisputesErrorCode.judgements_not_sorted_unique)

            # Process verdict
            if verdict.is_good():
                self.check_valid_faults_count(extrinsic_disputes.faults, verdict.target)
                bisect.insort(self.output.post_state.good_set, verdict.target)

            elif verdict.is_bad():
                self.check_valid_culprits_count(extrinsic_disputes.culprits, verdict.target)
                bisect.insort(self.output.post_state.bad_set, verdict.target)

            elif verdict.is_wonky():
                bisect.insort(self.output.post_state.wonky_set, verdict.target)
            else:
                raise StateTransitionError(DisputesErrorCode.bad_vote_split)

        # TODO: add reference to GP equations
        # Process culprits
        if not self.are_culprits_sorted(extrinsic_disputes.culprits):
            raise StateTransitionError(DisputesErrorCode.culprits_not_sorted_unique)

        for culprit in extrinsic_disputes.culprits:
            self.add_culprit(culprit)

        # TODO: add reference to GP equations
        # Process faults
        if not self.are_faults_sorted(extrinsic_disputes.faults):
            raise StateTransitionError(DisputesErrorCode.faults_not_sorted_unique)

        for fault in extrinsic_disputes.faults:
            self.add_fault(fault)

        return self.output

    @classmethod
    # TODO: proper documentation
    def has_valid_judgement_signatures(cls, verdict: Verdict, validators: List[ValidatorData]) -> bool:
        """
        GP-0.7.2-eq:10.3

        Parameters
        ----------
        verdict
        validators

        Returns
        -------

        """
        for judgement in verdict.votes:
            keypair = Ed25519Keypair.from_public_key(validators[judgement.index].ed25519)
            if not keypair.verify(judgement.get_signing_context() + verdict.target, judgement.signature):
                return False
        return True

    def is_already_judged(self, verdict: Verdict) -> bool:
        return (
                verdict.target in self.output.post_state.good_set or
                verdict.target in self.output.post_state.bad_set or
                verdict.target in self.output.post_state.wonky_set
        )

    @staticmethod
    # TODO: proper documentation
    def are_judgements_sorted(votes: List[Judgement]) -> bool:
        """
        GP-0.7.2-eq:10.10

        Parameters
        ----------
        votes

        Returns
        -------
        bool
        """
        return all(votes[i].index <= votes[i + 1].index for i in range(len(votes) - 1))

    @staticmethod
    # TODO: proper documentation
    def has_duplicate_judgements(votes: List[Judgement]) -> bool:
        """
        GP-0.7.2-eq:10.10

        Parameters
        ----------
        votes

        Returns
        -------
        bool
        """

        seen_indices = []
        for vote in votes:
            if vote.index in seen_indices:
                return True
            else:
                seen_indices.append(vote.index)
        return False

    @staticmethod
    # TODO: proper documentation
    def are_verdicts_sorted(verdicts: List[Verdict]) -> bool:
        """
        GP-0.7.2-eq:10.7

        Parameters
        ----------
        verdicts

        Returns
        -------
        bool
        """
        return all(verdicts[i].target <= verdicts[i + 1].target for i in range(len(verdicts) - 1))

    @staticmethod
    # TODO: proper documentation
    def are_culprits_sorted(culprits: List[Culprit]) -> bool:
        """
        GP-0.7.2-eq:10.8

        Parameters
        ----------
        culprits

        Returns
        -------
        bool
        """
        return all(culprits[i].key <= culprits[i + 1].key for i in range(len(culprits) - 1))

    @staticmethod
    # TODO: proper documentation
    def are_faults_sorted(faults: List[Fault]) -> bool:
        """
        GP-0.7.2-eq:10.8

        Parameters
        ----------
        faults

        Returns
        -------
        bool
        """
        return all(faults[i].key <= faults[i + 1].key for i in range(len(faults) - 1))

    @staticmethod
    def are_faults_verdict_correct(faults: List[Fault]) -> bool:
        return not any(f.vote for f in faults)

    def add_offender(self, offender_key: bytes):
        if offender_key in self.output.post_state.offenders:
            raise StateTransitionError(DisputesErrorCode.offender_already_reported)
        self.output.offenders_mark.append(offender_key)
        bisect.insort(self.output.post_state.offenders, offender_key)

    def add_culprit(self, culprit: Culprit):

        if culprit.target in self.output.post_state.bad_set:
            self.add_offender(culprit.key)
        else:
            raise StateTransitionError(DisputesErrorCode.culprits_verdict_not_bad)

    def add_fault(self, fault: Fault):

        if fault.target in self.output.post_state.good_set:
            self.add_offender(fault.key)
        else:
            raise StateTransitionError(DisputesErrorCode.fault_verdict_wrong)

    def retrieve_state(self) -> DisputesState:
        value = self.retrieve()
        return DisputesState.from_jam_bytes(JamBytes(value))

    @staticmethod
    # TODO: proper documentation
    def has_duplicate_report_hashes(verdicts: List[Verdict]) -> bool:
        """
        GP-0.7.2-eq:10.9

        Parameters
        ----------
        verdicts

        Returns
        -------
        bool
        """

        seen_targets = []
        for verdict in verdicts:
            if verdict.target in seen_targets:
                return True
            else:
                seen_targets.append(verdict.target)
        return False

    @staticmethod
    # TODO: proper documentation
    def check_valid_faults_count(faults: List[Fault], report_hash: bytes):
        """
        GP-0.7.2-eq:10.13

        Parameters
        ----------
        faults
        report_hash

        Returns
        -------

        """
        if sum(1 for f in faults if f.target == report_hash) == 0:
            raise StateTransitionError(DisputesErrorCode.not_enough_faults)

    @staticmethod
    # TODO: proper documentation
    def check_valid_culprits_count(culprits: List[Culprit], report_hash: bytes):
        """
        GP-0.7.2-eq:10.14

        Parameters
        ----------
        culprits
        report_hash

        Returns
        -------

        """
        if sum(1 for c in culprits if c.target == report_hash) < 2:
            raise StateTransitionError(DisputesErrorCode.not_enough_culprits)

    @classmethod
    def validate_extrinsic_disputes(
            cls,
            extrinsic_disputes: ExtrinsicDisputes,
            pre_state_timeslot: TimeslotState,
            pre_state_validator_pool: ValidatorPoolState,
            pre_state_validator_archive: ValidatorArchiveState
    ):
        current_epoch = pre_state_timeslot.number // gp_const.EPOCH_TIMESLOTS

        for verdict in extrinsic_disputes.verdicts:

            if current_epoch - verdict.age == 0:
                validators = pre_state_validator_pool.validators
            elif current_epoch - verdict.age == 1:
                validators = pre_state_validator_archive.validators
            else:
                raise BlockValidationError(DisputesErrorCode.bad_judgement_age)

            if not cls.has_valid_judgement_signatures(verdict, validators):
                raise BlockValidationError(DisputesErrorCode.bad_signature)

        validator_keys = [v.ed25519 for v in pre_state_validator_pool.validators]

        # GP-0.7.2-eq:10.5 | Check if culprit is in validator set
        for culprit in extrinsic_disputes.culprits:
            if culprit.key not in validator_keys:
                raise BlockValidationError(DisputesErrorCode.bad_guarantor_key)

        # GP-0.7.2-eq:10.6 | Check if faulty auditor is in validator set
        for fault in extrinsic_disputes.faults:
            if fault.key not in validator_keys:
                raise BlockValidationError(DisputesErrorCode.bad_auditor_key)

state_transition(extrinsic_disputes: ExtrinsicDisputes, pre_state_disputes: DisputesState) -> DisputesOutput

GP-0.7.2-eq:10.16,10.17,10.18,10.19 (ψ') | State transition function for the state's disputes.

Parameters:

Name	Type	Description	Default
extrinsic_disputes	ExtrinsicDisputes	GP-0.7.2-eq:4.11 (bold_E_D)	required
pre_state_disputes	DisputesState	GP-0.7.2-eq:4.11 (ψ)	required

Returns:

Type	Description
DisputesOutput	Output containing: Posterior state of DisputesState (ψ')

Source code in pyjamaz/state/components.py

@log_execution_time
def state_transition(
        self,
        extrinsic_disputes: ExtrinsicDisputes,
        pre_state_disputes: DisputesState
) -> DisputesOutput:
    """
    GP-0.7.2-eq:10.16,10.17,10.18,10.19 (ψ') | State transition function for the state's disputes.

    Parameters
    ----------
    extrinsic_disputes: ExtrinsicDisputes
        GP-0.7.2-eq:4.11 (bold_E_D)
    pre_state_disputes: DisputesState
        GP-0.7.2-eq:4.11 (ψ)

    Returns
    -------
    DisputesOutput
        Output containing: Posterior state of DisputesState (ψ')
    """

    self.output = DisputesOutput(
        post_state=deepcopy(pre_state_disputes), offenders_mark=[]
    )

    if not self.are_faults_verdict_correct(extrinsic_disputes.faults):
        raise StateTransitionError(DisputesErrorCode.fault_verdict_wrong)

    # GP-0.7.2-eq:10.2 | Check if all culprits have valid signatures
    if not all(c.has_valid_signature() for c in extrinsic_disputes.culprits):
        raise StateTransitionError(DisputesErrorCode.bad_signature)

    # GP-0.7.2-eq:10.2 | Check if all faults have valid signatures
    if not all(f.has_valid_signature() for f in extrinsic_disputes.faults):
        raise StateTransitionError(DisputesErrorCode.bad_signature)

    # GP-0.7.2-eq:10.7 | Check if verdicts are sorted
    if not self.are_verdicts_sorted(extrinsic_disputes.verdicts):
        raise StateTransitionError(DisputesErrorCode.verdicts_not_sorted_unique)

    if self.has_duplicate_report_hashes(extrinsic_disputes.verdicts):
        raise StateTransitionError(DisputesErrorCode.verdicts_not_sorted_unique)

    # TODO: add reference to GP equations
    # Process verdicts
    for verdict in extrinsic_disputes.verdicts:

        if self.is_already_judged(verdict):
            raise StateTransitionError(DisputesErrorCode.already_judged)

        # GP-0.7.2-eq:10.10 | Check if judgements are sorted and unique
        if not self.are_judgements_sorted(verdict.votes) or self.has_duplicate_judgements(verdict.votes):
            raise StateTransitionError(DisputesErrorCode.judgements_not_sorted_unique)

        # Process verdict
        if verdict.is_good():
            self.check_valid_faults_count(extrinsic_disputes.faults, verdict.target)
            bisect.insort(self.output.post_state.good_set, verdict.target)

        elif verdict.is_bad():
            self.check_valid_culprits_count(extrinsic_disputes.culprits, verdict.target)
            bisect.insort(self.output.post_state.bad_set, verdict.target)

        elif verdict.is_wonky():
            bisect.insort(self.output.post_state.wonky_set, verdict.target)
        else:
            raise StateTransitionError(DisputesErrorCode.bad_vote_split)

    # TODO: add reference to GP equations
    # Process culprits
    if not self.are_culprits_sorted(extrinsic_disputes.culprits):
        raise StateTransitionError(DisputesErrorCode.culprits_not_sorted_unique)

    for culprit in extrinsic_disputes.culprits:
        self.add_culprit(culprit)

    # TODO: add reference to GP equations
    # Process faults
    if not self.are_faults_sorted(extrinsic_disputes.faults):
        raise StateTransitionError(DisputesErrorCode.faults_not_sorted_unique)

    for fault in extrinsic_disputes.faults:
        self.add_fault(fault)

    return self.output

has_valid_judgement_signatures(verdict: Verdict, validators: List[ValidatorData]) -> bool classmethod

GP-0.7.2-eq:10.3

Parameters:

Name	Type	Description	Default
verdict	Verdict		required
validators	List[ValidatorData]		required

Source code in pyjamaz/state/components.py

@classmethod
# TODO: proper documentation
def has_valid_judgement_signatures(cls, verdict: Verdict, validators: List[ValidatorData]) -> bool:
    """
    GP-0.7.2-eq:10.3

    Parameters
    ----------
    verdict
    validators

    Returns
    -------

    """
    for judgement in verdict.votes:
        keypair = Ed25519Keypair.from_public_key(validators[judgement.index].ed25519)
        if not keypair.verify(judgement.get_signing_context() + verdict.target, judgement.signature):
            return False
    return True

are_judgements_sorted(votes: List[Judgement]) -> bool staticmethod

GP-0.7.2-eq:10.10

Parameters:

Name	Type	Description	Default
votes	List[Judgement]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def are_judgements_sorted(votes: List[Judgement]) -> bool:
    """
    GP-0.7.2-eq:10.10

    Parameters
    ----------
    votes

    Returns
    -------
    bool
    """
    return all(votes[i].index <= votes[i + 1].index for i in range(len(votes) - 1))

has_duplicate_judgements(votes: List[Judgement]) -> bool staticmethod

GP-0.7.2-eq:10.10

Parameters:

Name	Type	Description	Default
votes	List[Judgement]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def has_duplicate_judgements(votes: List[Judgement]) -> bool:
    """
    GP-0.7.2-eq:10.10

    Parameters
    ----------
    votes

    Returns
    -------
    bool
    """

    seen_indices = []
    for vote in votes:
        if vote.index in seen_indices:
            return True
        else:
            seen_indices.append(vote.index)
    return False

are_verdicts_sorted(verdicts: List[Verdict]) -> bool staticmethod

GP-0.7.2-eq:10.7

Parameters:

Name	Type	Description	Default
verdicts	List[Verdict]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def are_verdicts_sorted(verdicts: List[Verdict]) -> bool:
    """
    GP-0.7.2-eq:10.7

    Parameters
    ----------
    verdicts

    Returns
    -------
    bool
    """
    return all(verdicts[i].target <= verdicts[i + 1].target for i in range(len(verdicts) - 1))

are_culprits_sorted(culprits: List[Culprit]) -> bool staticmethod

GP-0.7.2-eq:10.8

Parameters:

Name	Type	Description	Default
culprits	List[Culprit]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def are_culprits_sorted(culprits: List[Culprit]) -> bool:
    """
    GP-0.7.2-eq:10.8

    Parameters
    ----------
    culprits

    Returns
    -------
    bool
    """
    return all(culprits[i].key <= culprits[i + 1].key for i in range(len(culprits) - 1))

are_faults_sorted(faults: List[Fault]) -> bool staticmethod

GP-0.7.2-eq:10.8

Parameters:

Name	Type	Description	Default
faults	List[Fault]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def are_faults_sorted(faults: List[Fault]) -> bool:
    """
    GP-0.7.2-eq:10.8

    Parameters
    ----------
    faults

    Returns
    -------
    bool
    """
    return all(faults[i].key <= faults[i + 1].key for i in range(len(faults) - 1))

has_duplicate_report_hashes(verdicts: List[Verdict]) -> bool staticmethod

GP-0.7.2-eq:10.9

Parameters:

Name	Type	Description	Default
verdicts	List[Verdict]		required

Returns:

Type	Description
bool

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def has_duplicate_report_hashes(verdicts: List[Verdict]) -> bool:
    """
    GP-0.7.2-eq:10.9

    Parameters
    ----------
    verdicts

    Returns
    -------
    bool
    """

    seen_targets = []
    for verdict in verdicts:
        if verdict.target in seen_targets:
            return True
        else:
            seen_targets.append(verdict.target)
    return False

check_valid_faults_count(faults: List[Fault], report_hash: bytes) staticmethod

GP-0.7.2-eq:10.13

Parameters:

Name	Type	Description	Default
faults	List[Fault]		required
report_hash	bytes		required

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def check_valid_faults_count(faults: List[Fault], report_hash: bytes):
    """
    GP-0.7.2-eq:10.13

    Parameters
    ----------
    faults
    report_hash

    Returns
    -------

    """
    if sum(1 for f in faults if f.target == report_hash) == 0:
        raise StateTransitionError(DisputesErrorCode.not_enough_faults)

check_valid_culprits_count(culprits: List[Culprit], report_hash: bytes) staticmethod

GP-0.7.2-eq:10.14

Parameters:

Name	Type	Description	Default
culprits	List[Culprit]		required
report_hash	bytes		required

Source code in pyjamaz/state/components.py

@staticmethod
# TODO: proper documentation
def check_valid_culprits_count(culprits: List[Culprit], report_hash: bytes):
    """
    GP-0.7.2-eq:10.14

    Parameters
    ----------
    culprits
    report_hash

    Returns
    -------

    """
    if sum(1 for c in culprits if c.target == report_hash) < 2:
        raise StateTransitionError(DisputesErrorCode.not_enough_culprits)