patchr 0.1.0__py3-none-any.whl

picux/storage/escrows.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import copy
+import time
+from typing import Any
+
+
+ESCROW_STATUSES = {
+    "pending",
+    "created",
+    "funded",
+    "awaitingProof",
+    "settled",
+    "rejected",
+    "refunded",
+    "disputed",
+    "slashed",
+    "frozen",
+    "canceled",
+}
+
+
+class EscrowBook:
+    """Escrow record storage with optional durable backing."""
+
+    def __init__(self, *, backing: Any | None = None) -> None:
+        self.backing = backing
+        self._records: dict[str, dict[str, Any]] = {}
+
+    def saveEscrow(self, payload: dict[str, Any], *, status: str = "pending") -> dict[str, Any]:
+        escrowId = str(payload.get("escrowId", "") or "")
+        if not escrowId:
+            return {"ok": False, "error": "missing:escrowId"}
+        current = self.getEscrow(escrowId)
+        now = int(time.time())
+        createdAt = current.get("escrow", {}).get("createdAt", now) if current.get("ok") else now
+        record = _recordFromPayload(payload, status=status, createdAt=createdAt, updatedAt=now)
+        self._saveRecord(record)
+        return {"ok": True, "escrow": copy.deepcopy(record)}
+
+    def getEscrow(self, escrowId: str) -> dict[str, Any]:
+        escrowId = str(escrowId or "")
+        record = self._records.get(escrowId)
+        if record is None and self._backingEnabled() and hasattr(self.backing, "fetchEscrow"):
+            record = self.backing.fetchEscrow(escrowId)
+            if record:
+                self._records[escrowId] = copy.deepcopy(record)
+        if not record:
+            return {"ok": False, "error": "escrowNotFound", "escrowId": escrowId}
+        return {"ok": True, "escrow": copy.deepcopy(record)}
+
+    def listEscrows(self, filters: dict[str, Any] | None = None) -> dict[str, Any]:
+        self._loadBacking()
+        filters = filters or {}
+        status = str(filters.get("status", "") or "")
+        mandateId = str(filters.get("mandateId", "") or "")
+        taskId = str(filters.get("taskId", "") or "")
+        records = list(self._records.values())
+        if status:
+            records = [record for record in records if record.get("status") == status]
+        if mandateId:
+            records = [record for record in records if record.get("mandateId") == mandateId]
+        if taskId:
+            records = [record for record in records if record.get("taskId") == taskId]
+        records.sort(
+            key=lambda item: (int(item.get("createdAt", 0) or 0), str(item.get("escrowId", ""))),
+            reverse=True,
+        )
+        limit = _limit(filters.get("limit", 100))
+        return {
+            "ok": True,
+            "escrows": [copy.deepcopy(record) for record in records[:limit]],
+            "count": min(len(records), limit),
+        }
+
+    def updateEscrow(self, escrowId: str, updates: dict[str, Any]) -> dict[str, Any]:
+        current = self.getEscrow(escrowId)
+        if not current.get("ok"):
+            return current
+        record = current["escrow"]
+        status = _status(updates.get("status", record.get("status", "pending")))
+        payload = record.get("payload", {}) if isinstance(record.get("payload"), dict) else {}
+        if isinstance(updates.get("payload"), dict):
+            payload = copy.deepcopy(updates["payload"])
+        decision = record.get("decision", {}) if isinstance(record.get("decision"), dict) else {}
+        if isinstance(updates.get("decision"), dict):
+            decision = copy.deepcopy(updates["decision"])
+        merged = {
+            **record,
+            "status": status,
+            "mandateId": str(updates.get("mandateId", record.get("mandateId", "")) or ""),
+            "taskId": str(updates.get("taskId", record.get("taskId", "")) or ""),
+            "amount": _amount(updates.get("amount", record.get("amount", {}))),
+            "povRef": str(updates.get("povRef", record.get("povRef", "")) or ""),
+            "receiptId": str(updates.get("receiptId", record.get("receiptId", "")) or ""),
+            "payload": payload,
+            "decision": decision,
+            "updatedAt": int(updates.get("updatedAt", int(time.time())) or int(time.time())),
+        }
+        self._saveRecord(merged)
+        return {"ok": True, "escrow": copy.deepcopy(merged)}
+
+    def _saveRecord(self, record: dict[str, Any]) -> None:
+        escrowId = str(record.get("escrowId", "") or "")
+        if not escrowId:
+            return
+        self._records[escrowId] = copy.deepcopy(record)
+        if self._backingEnabled() and hasattr(self.backing, "upsertEscrow"):
+            self.backing.upsertEscrow(record)
+
+    def _loadBacking(self) -> None:
+        if self.backing is None or not self._backingEnabled() or not hasattr(self.backing, "listEscrows"):
+            return
+        for record in self.backing.listEscrows():
+            escrowId = str(record.get("escrowId", "") or "")
+            if escrowId:
+                self._records[escrowId] = copy.deepcopy(record)
+
+    def _backingEnabled(self) -> bool:
+        if self.backing is None:
+            return False
+        return bool(getattr(self.backing, "enabled", True))
+
+
+def _recordFromPayload(payload: dict[str, Any], *, status: str, createdAt: int, updatedAt: int) -> dict[str, Any]:
+    request = payload.get("request", {}) if isinstance(payload.get("request"), dict) else payload
+    mandate = payload.get("paymentMandate", {}) if isinstance(payload.get("paymentMandate"), dict) else {}
+    if not mandate:
+        mandate = payload.get("mandate", {}) if isinstance(payload.get("mandate"), dict) else {}
+    pov = request.get("pov", {}) if isinstance(request.get("pov"), dict) else {}
+    return {
+        "escrowId": str(payload.get("escrowId", "") or ""),
+        "status": _status(payload.get("status", status)),
+        "mandateId": str(payload.get("mandateId", mandate.get("mandateId", request.get("mandateId", ""))) or ""),
+        "taskId": str(payload.get("taskId", request.get("taskId", "")) or ""),
+        "amount": _amount(payload.get("amount", request.get("amount", {}))),
+        "povRef": str(payload.get("povRef", pov.get("povId", "")) or ""),
+        "receiptId": str(payload.get("receiptId", "") or ""),
+        "payload": copy.deepcopy(payload),
+        "decision": payload.get("decision", {}) if isinstance(payload.get("decision"), dict) else {},
+        "createdAt": int(createdAt or updatedAt),
+        "updatedAt": int(updatedAt or createdAt),
+    }
+
+
+def _amount(value: Any) -> dict[str, Any]:
+    amount = value if isinstance(value, dict) else {}
+    try:
+        parsed = float(amount.get("amount", 0.0) or 0.0)
+    except (TypeError, ValueError):
+        parsed = 0.0
+    return {
+        "amount": round(max(0.0, parsed), 2),
+        "currency": str(amount.get("currency", "USD") or "USD").upper(),
+    }
+
+
+def _status(value: Any) -> str:
+    status = str(value or "pending")
+    return status if status in ESCROW_STATUSES else "pending"
+
+
+def _limit(value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return 100
+    return max(1, min(parsed, 500))