raiden/raiden/transfer/mediated_transfer/state_change.py at bd039333f1602f85548df22b6aa875ba12be0f46 · raiden-network/raiden · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# pylint: disable=too-few-public-methods,too-many-arguments,too-many-instance-attributes
from dataclasses import dataclass, field

from raiden.constants import EMPTY_SECRETHASH
from raiden.transfer.architecture import AuthenticatedSenderStateChange, StateChange
from raiden.transfer.mediated_transfer.events import SendSecretReveal
from raiden.transfer.mediated_transfer.state import (
    LockedTransferSignedState,
    TransferDescriptionWithSecretState,
)
from raiden.transfer.state import HopState, RouteState
from raiden.transfer.state_change import BalanceProofStateChange
from raiden.utils.secrethash import sha256_secrethash
from raiden.utils.typing import (
    BlockExpiration,
    List,
    MessageID,
    Optional,
    PaymentAmount,
    PaymentID,
    Secret,
    SecretHash,
    typecheck,
)


# Note: The init states must contain all the required data for trying doing
# useful work, ie. there must /not/ be an event for requesting new data.
@dataclass(frozen=True)
class ActionInitInitiator(StateChange):
    """Initial state of a new mediated transfer."""

    transfer: TransferDescriptionWithSecretState
    routes: List[RouteState]

    def __post_init__(self) -> None:
        typecheck(self.transfer, TransferDescriptionWithSecretState)


@dataclass(frozen=True)
class ActionInitMediator(BalanceProofStateChange):
    """Initial state for a new mediator.

    Args:
        from_hop: The payee route.
        route_states: list of forward route states.
        from_transfer: The payee transfer.
    """

    from_hop: HopState
    candidate_route_states: List[RouteState]
    from_transfer: LockedTransferSignedState

    def __post_init__(self) -> None:
        super().__post_init__()
        typecheck(self.from_hop, HopState)
        typecheck(self.from_transfer, LockedTransferSignedState)


@dataclass(frozen=True)
class ActionInitTarget(BalanceProofStateChange):
    """Initial state for a new target.

    Args:
        from_hop: The payee route.
        transfer: The payee transfer.
    """

    from_hop: HopState
    transfer: LockedTransferSignedState
    received_valid_secret: Optional[bool] = field(default=False)

    def __post_init__(self) -> None:
        super().__post_init__()
        typecheck(self.from_hop, HopState)
        typecheck(self.transfer, LockedTransferSignedState)


@dataclass(frozen=True)
class ActionTransferReroute(BalanceProofStateChange):
    """A transfer will be rerouted

    Args:
        transfer: the transfer being re-routed
        secret: the new secret
        secrethash: the new secrethash
    """

    transfer: LockedTransferSignedState
    secret: Secret = field(repr=False)
    secrethash: SecretHash = field(default=EMPTY_SECRETHASH)

    def __post_init__(self) -> None:
        super().__post_init__()
        typecheck(self.transfer, LockedTransferSignedState)

        object.__setattr__(self, "secrethash", sha256_secrethash(self.secret))


@dataclass(frozen=True)
class ReceiveTransferCancelRoute(BalanceProofStateChange):
    """A mediator sends us a refund due to a failed route"""

    transfer: LockedTransferSignedState


@dataclass(frozen=True)
class ReceiveLockExpired(BalanceProofStateChange):
    """A LockExpired message received."""

    secrethash: SecretHash
    message_identifier: MessageID


@dataclass(frozen=True)
class ReceiveSecretRequest(AuthenticatedSenderStateChange):
    """A SecretRequest message received."""

    payment_identifier: PaymentID
    amount: PaymentAmount
    expiration: BlockExpiration = field(repr=False)
    secrethash: SecretHash
    revealsecret: Optional[SendSecretReveal] = field(default=None)


@dataclass(frozen=True)
class ReceiveSecretReveal(AuthenticatedSenderStateChange):
    """A SecretReveal message received."""

    secret: Secret = field(repr=False)
    secrethash: SecretHash = field(default=EMPTY_SECRETHASH)

    def __post_init__(self) -> None:
        object.__setattr__(self, "secrethash", sha256_secrethash(self.secret))


@dataclass(frozen=True)
class ReceiveTransferRefund(BalanceProofStateChange):
    """A RefundTransfer message received."""

    transfer: LockedTransferSignedState

    def __post_init__(self) -> None:
        super().__post_init__()

        typecheck(self.transfer, LockedTransferSignedState)