122 lines
3.0 KiB
Python
122 lines
3.0 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
from dataclasses import dataclass, asdict, field
|
|
from typing import Dict, Any, List, Optional
|
|
|
|
|
|
def to_json(obj: Any) -> str:
|
|
return json.dumps(obj, default=lambda o: o.__dict__, sort_keys=True)
|
|
|
|
|
|
@dataclass
|
|
class LocalExecutionTask:
|
|
"""Canonical LocalExecutionTask per instrument/venue planning unit."""
|
|
task_id: str
|
|
instrument: str
|
|
venue: str
|
|
objective: str
|
|
constraints: Dict[str, Any] = field(default_factory=dict)
|
|
|
|
def to_json(self) -> str:
|
|
return to_json(asdict(self))
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return asdict(self)
|
|
|
|
|
|
@dataclass
|
|
class SharedMarketContext:
|
|
"""Canonical SharedMarketContext with privacy-safe signals."""
|
|
signals: Dict[str, Any]
|
|
version: int
|
|
contract_id: str
|
|
|
|
def to_json(self) -> str:
|
|
return to_json(asdict(self))
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return asdict(self)
|
|
|
|
|
|
@dataclass
|
|
class PlanDelta:
|
|
"""Incremental routing/size/timing decisions with metadata."""
|
|
delta: Dict[str, Any]
|
|
timestamp: float
|
|
author: str
|
|
contract_id: str
|
|
privacy_budget: Optional[float] = None
|
|
|
|
def to_json(self) -> str:
|
|
return to_json(asdict(self))
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return asdict(self)
|
|
|
|
|
|
@dataclass
|
|
class Attestation:
|
|
"""Cryptographic attestation for a delta or event."""
|
|
entry: str
|
|
signer: str
|
|
timestamp: float
|
|
contract_id: str
|
|
version: int
|
|
signature: Optional[str] = None
|
|
|
|
def to_json(self) -> str:
|
|
return to_json(asdict(self))
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return asdict(self)
|
|
|
|
|
|
@dataclass
|
|
class AuditLog:
|
|
"""Append-only log of attestations and approvals."""
|
|
entries: List[Attestation] = field(default_factory=list)
|
|
|
|
def add(self, attestation: Attestation) -> None:
|
|
self.entries.append(attestation)
|
|
|
|
def to_json(self) -> str:
|
|
return to_json([asdict(entry) for entry in self.entries])
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {"entries": [e.to_dict() for e in self.entries]}
|
|
|
|
|
|
@dataclass
|
|
class GraphOfContracts:
|
|
"""Registry for adapters and data-contract schemas."""
|
|
registry: Dict[str, Any]
|
|
version: int = 1
|
|
adapters: Optional[Dict[str, Any]] = None
|
|
|
|
def __post_init__(self) -> None:
|
|
if self.adapters is None:
|
|
self.adapters = self.registry
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
return {"registry": self.registry, "version": self.version, "adapters": self.adapters}
|
|
|
|
|
|
def compute_delta(task: LocalExecutionTask, ctx: SharedMarketContext) -> PlanDelta:
|
|
"""Deterministic, minimal PlanDelta from inputs."""
|
|
delta = {
|
|
"action": "hold",
|
|
"reason": "base-case",
|
|
"task_id": task.task_id,
|
|
"instrument": task.instrument,
|
|
"venue": task.venue,
|
|
"constraints_snapshot": task.constraints,
|
|
}
|
|
return PlanDelta(
|
|
delta=delta,
|
|
timestamp=0.0,
|
|
author="exprove-solver",
|
|
contract_id=ctx.contract_id,
|
|
privacy_budget=0.0,
|
|
)
|