Coverage for src/copytrading_engine/host/pipe/handlers/trading.py: 83%

68 statements  

« prev     ^ index     » next       coverage.py v7.16.2, created at 2026-11-16 16:55 +0000

1"""Start, pause, and check copying: validation grants an activation token.""" 

2 

3import hashlib 

4import hmac 

5import json 

6import os 

7import time 

8from dataclasses import dataclass 

9from uuid import uuid4 

10 

11from copytrading_engine.host.pipe.requests import ( 

12 CheckConnectionRequest, 

13 GetTradingActivationRequest, 

14 GetTradingStatusRequest, 

15 PauseTradingRequest, 

16 PipeRequest, 

17 RequestHandler, 

18 StartTradingRequest, 

19 UpdateAccountLimitsRequest, 

20 ValidateTradingRequest, 

21) 

22from copytrading_engine.host.pipe.responses import reply, trading_reply 

23from copytrading_engine.host.pipe.services import TradingServices 

24from copytrading_engine.trading.domain.config import TradingSecrets 

25 

26 

27@dataclass(frozen=True) 

28class _ActivationGrant: 

29 token: str 

30 configuration_revision: str 

31 secret_fingerprint: str 

32 expires_at: float 

33 

34 

35class TradingLifecycleHandlers: 

36 """Validate, start, and pause copying; starting needs the latest validation's token.""" 

37 

38 def __init__(self, *, trading: TradingServices | None) -> None: 

39 self._trading = trading 

40 self._activation_key = os.urandom(32) 

41 self._activation_grant: _ActivationGrant | None = None 

42 

43 def handlers(self) -> dict[type[PipeRequest], RequestHandler]: 

44 return { 

45 GetTradingStatusRequest: self._on_get_trading_status, 

46 GetTradingActivationRequest: self._on_get_trading_activation, 

47 ValidateTradingRequest: self._on_validate_trading, 

48 CheckConnectionRequest: self._on_check_connection, 

49 StartTradingRequest: self._on_start_trading, 

50 PauseTradingRequest: self._on_pause_trading, 

51 UpdateAccountLimitsRequest: self._on_update_account_limits, 

52 } 

53 

54 async def _on_get_trading_status(self, request: GetTradingStatusRequest) -> bytes: 

55 if self._trading is None: 55 ↛ 56line 55 didn't jump to line 56 because the condition on line 55 was never true

56 return reply(request.version, request.request_id, error="unavailable") 

57 status = self._trading.lifecycle.status() 

58 return trading_reply(request.version, request.request_id, status) 

59 

60 async def _on_get_trading_activation(self, request: GetTradingActivationRequest) -> bytes: 

61 if self._trading is None: 61 ↛ 62line 61 didn't jump to line 62 because the condition on line 61 was never true

62 return reply(request.version, request.request_id, error="unavailable") 

63 status = self._trading.lifecycle.activation_status(request.activation_id) 

64 return reply( 

65 request.version, 

66 request.request_id, 

67 ok={"type": "trading_activation", "activation": status.model_dump(mode="json")}, 

68 ) 

69 

70 async def _on_validate_trading(self, request: ValidateTradingRequest) -> bytes: 

71 if self._trading is None: 71 ↛ 72line 71 didn't jump to line 72 because the condition on line 71 was never true

72 return reply(request.version, request.request_id, error="unavailable") 

73 report = await self._trading.lifecycle.validate(request.configuration, request.secrets) 

74 self._activation_grant = None 

75 token = None 

76 if report.activatable: 76 ↛ 84line 76 didn't jump to line 84 because the condition on line 76 was always true

77 token = uuid4().hex 

78 self._activation_grant = _ActivationGrant( 

79 token=token, 

80 configuration_revision=request.configuration.revision(), 

81 secret_fingerprint=self._secret_fingerprint(request.secrets), 

82 expires_at=time.monotonic() + 120, 

83 ) 

84 return reply( 

85 request.version, 

86 request.request_id, 

87 ok={ 

88 "type": "trading_validation", 

89 "report": report.model_dump(mode="json"), 

90 "activation_token": token, 

91 }, 

92 ) 

93 

94 async def _on_check_connection(self, request: CheckConnectionRequest) -> bytes: 

95 """A single service's check never touches the start grant a full validation holds.""" 

96 if self._trading is None: 96 ↛ 97line 96 didn't jump to line 97 because the condition on line 96 was never true

97 return reply(request.version, request.request_id, error="unavailable") 

98 check = await self._trading.lifecycle.check_connection(request.connection) 

99 return reply( 

100 request.version, 

101 request.request_id, 

102 ok={"type": "connection_check", "check": check.model_dump(mode="json")}, 

103 ) 

104 

105 async def _on_start_trading(self, request: StartTradingRequest) -> bytes: 

106 if self._trading is None: 106 ↛ 107line 106 didn't jump to line 107 because the condition on line 106 was never true

107 return reply(request.version, request.request_id, error="unavailable") 

108 grant = self._activation_grant 

109 self._activation_grant = None 

110 if ( 

111 grant is None 

112 or grant.token != request.validation_token 

113 or grant.configuration_revision != request.configuration.revision() 

114 or grant.secret_fingerprint != self._secret_fingerprint(request.secrets) 

115 or grant.expires_at < time.monotonic() 

116 ): 

117 return reply(request.version, request.request_id, error="invalid_request") 

118 status = await self._trading.lifecycle.start( 

119 request.configuration, request.secrets, request.activation_id 

120 ) 

121 return trading_reply(request.version, request.request_id, status) 

122 

123 async def _on_pause_trading(self, request: PauseTradingRequest) -> bytes: 

124 if self._trading is None: 124 ↛ 125line 124 didn't jump to line 125 because the condition on line 124 was never true

125 return reply(request.version, request.request_id, error="unavailable") 

126 status = await self._trading.lifecycle.pause() 

127 return trading_reply(request.version, request.request_id, status) 

128 

129 async def _on_update_account_limits(self, request: UpdateAccountLimitsRequest) -> bytes: 

130 """Limits apply while copying runs; the reply's revision is what the app saves.""" 

131 if self._trading is None: 131 ↛ 132line 131 didn't jump to line 132 because the condition on line 131 was never true

132 return reply(request.version, request.request_id, error="unavailable") 

133 revision = await self._trading.lifecycle.update_account_limits(request.configuration) 

134 return reply( 

135 request.version, 

136 request.request_id, 

137 ok={"type": "account_limits", "revision": revision}, 

138 ) 

139 

140 def _secret_fingerprint(self, secrets: TradingSecrets) -> str: 

141 payload = { 

142 "discord_token": secrets.discord_token.get_secret_value(), 

143 "provider_api_key": secrets.provider_api_key.get_secret_value(), 

144 "brokers": [ 

145 { 

146 "account_id": item.account_id, 

147 "key": item.key.get_secret_value(), 

148 "secret": item.secret.get_secret_value(), 

149 } 

150 for item in sorted(secrets.brokers, key=lambda value: value.account_id) 

151 ], 

152 "notification_token": ( 

153 secrets.notification_token.get_secret_value() 

154 if secrets.notification_token is not None 

155 else None 

156 ), 

157 } 

158 encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode() 

159 return hmac.new(self._activation_key, encoded, hashlib.sha256).hexdigest()