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
« 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."""
3import hashlib
4import hmac
5import json
6import os
7import time
8from dataclasses import dataclass
9from uuid import uuid4
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
27@dataclass(frozen=True)
28class _ActivationGrant:
29 token: str
30 configuration_revision: str
31 secret_fingerprint: str
32 expires_at: float
35class TradingLifecycleHandlers:
36 """Validate, start, and pause copying; starting needs the latest validation's token."""
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
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 }
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)
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 )
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 )
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 )
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)
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)
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 )
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()