v15.1.3 (#54)

Author: truemagic-coder

.coverage

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sakit"
-version = "15.1.2"
+version = "15.1.3"
 description = "Solana Agent Kit"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"

pyproject.toml

@@ -444,6 +444,7 @@ async def sign_and_send(tx_b64: str) -> str:
                         "amount_in": f"{amount} USDC",
                         "tokens_received": result.out_amount,
                         "signature": result.signature,
+                        "tx_signature": result.signature,
                         "execution_mode": result.execution_mode,
                         "safety": safety,
                     }
@@ -524,6 +525,7 @@ async def sign_and_send(tx_b64: str) -> str:
                         "tokens_sold": f"{amount} {side.upper()}",
                         "usdc_received": result.out_amount,
                         "signature": result.signature,
+                        "tx_signature": result.signature,
                         "execution_mode": result.execution_mode,
                     }
                 else:

sakit/dflow_prediction.py

@@ -701,6 +701,7 @@ async def sign_and_send(tx_b64: str) -> str:  # pragma: no cover
                         "amount_in": f"{amount} USDC",
                         "tokens_received": result.out_amount,
                         "signature": result.signature,
+                        "tx_signature": result.signature,
                         "execution_mode": result.execution_mode,
                         "wallet": wallet_address,
                         "safety": safety,
@@ -813,6 +814,7 @@ async def sign_and_send(tx_b64: str) -> str:  # pragma: no cover
                         "tokens_sold": f"{amount} {side.upper()}",
                         "usdc_received": result.out_amount,
                         "signature": result.signature,
+                        "tx_signature": result.signature,
                         "execution_mode": result.execution_mode,
                         "wallet": wallet_address,
                     }

sakit/privy_dflow_prediction.py

@@ -34,6 +34,7 @@
 DFLOW_METADATA_API = "https://prediction-markets-api.dflow.net/api/v1"
 
 # Known verified series for safety scoring
+# These are well-established markets with clear resolution criteria
 KNOWN_SERIES = {
     "US-POLITICS",
     "US-ELECTIONS",
@@ -47,6 +48,22 @@
     "ECONOMICS",
 }
 
+# Series prefixes that indicate verified/safe markets (e.g., Kalshi markets)
+SAFE_SERIES_PREFIXES = {
+    "KX",  # Kalshi Exchange - regulated, clear resolution
+    "POLY",  # Polymarket - established platform
+}
+
+# Categories that have objectively verifiable outcomes (binary, date-bound)
+OBJECTIVE_CATEGORIES = {
+    "politics",
+    "elections",
+    "sports",
+    "fed",
+    "economics",
+    "crypto-price",
+}
+
 # Default quality filters
 DEFAULT_MIN_VOLUME_USD = 1000
 DEFAULT_MIN_LIQUIDITY_USD = 500
@@ -424,16 +441,49 @@ def calculate_safety_score(
     score_points = 100
     now = current_time or int(time.time())
 
-    # Age check
+    # Get market identifiers
+    ticker = market.get("ticker", "") or ""
+    series_ticker = market.get("seriesTicker") or market.get("series_ticker", "") or ""
+    category = (market.get("category", "") or "").lower()
+
+    # Check if this is a verified/regulated market (Kalshi, Polymarket, etc.)
+    is_verified_platform = any(
+        ticker.upper().startswith(prefix) or series_ticker.upper().startswith(prefix)
+        for prefix in SAFE_SERIES_PREFIXES
+    )
+
+    # Check if this is a known established series
+    is_known_series = any(
+        series_ticker.upper().startswith(known) for known in KNOWN_SERIES
+    )
+
+    # Check if the market has objectively verifiable outcomes
+    has_clear_resolution_date = bool(
+        market.get("closeTime") or market.get("expirationTime") or market.get("endDate")
+    )
+    is_objective_category = category in OBJECTIVE_CATEGORIES
+
+    # Verified platforms with clear dates are HIGH safety - skip other checks
+    if is_verified_platform and has_clear_resolution_date:
+        # These are regulated markets with binary outcomes and set dates
+        return SafetyResult("HIGH", [], "PROCEED")
+
+    # Known series with clear dates also get a boost
+    if is_known_series and has_clear_resolution_date:
+        return SafetyResult("HIGH", [], "PROCEED")
+
+    # Age check - less strict for verified platforms
     created_at = market.get("createdAt") or market.get("openTime")
     if created_at:
         age_hours = (now - created_at) / 3600
         if age_hours < 24:
-            warnings.append("New market (< 24 hours old)")
-            score_points -= 30
+            if not is_verified_platform:
+                warnings.append("New market (< 24 hours old)")
+                score_points -= 30
         elif age_hours < 168:  # 7 days
-            warnings.append("Young market (< 7 days old)")
-            score_points -= 15
+            if not is_verified_platform:
+                warnings.append("Young market (< 7 days old)")
+                score_points -= 15
 
     # Volume check
     volume = market.get("volume", 0)
@@ -461,22 +511,21 @@ def calculate_safety_score(
             warnings.append("No trades in 24 hours")
             score_points -= 20
 
-    # Series verification
-    series_ticker = market.get("seriesTicker") or market.get("series_ticker", "")
-    # Check if any known series is a prefix of the series ticker
-    is_known_series = any(
-        series_ticker.upper().startswith(known) for known in KNOWN_SERIES
-    )
-    if not is_known_series and series_ticker:
+    # Series verification - only penalize if not verified platform
+    if not is_known_series and not is_verified_platform and series_ticker:
         warnings.append("Unknown/unverified series")
         score_points -= 15
 
-    # Resolution clarity check
+    # Resolution clarity check - verified platforms have clear rules by default
     rules = market.get("rulesPrimary", "")
-    if not rules or len(rules) < 50:
+    if not is_verified_platform and (not rules or len(rules) < 50):
         warnings.append("Unclear resolution criteria")
         score_points -= 20
 
+    # Boost for objective categories with clear dates
+    if is_objective_category and has_clear_resolution_date:
+        score_points += 15
+
     # Calculate final score
     if score_points >= 70:
         return SafetyResult("HIGH", warnings, "PROCEED")
@@ -547,12 +596,32 @@ def _add_safety_scores(
         items: List[Dict[str, Any]],
         trades_by_ticker: Optional[Dict[str, List[Dict[str, Any]]]] = None,
     ) -> List[Dict[str, Any]]:
-        """Add safety scores to markets/events."""
+        """Add safety scores and formatted resolution dates to markets/events."""
+        from datetime import datetime
+
         for item in items:
             ticker = item.get("ticker", "")
             trades = trades_by_ticker.get(ticker) if trades_by_ticker else None
             safety = calculate_safety_score(item, trades)
             item["safety"] = safety.to_dict()
+
+            # Add human-readable resolution date
+            close_time = (
+                item.get("closeTime")
+                or item.get("expirationTime")
+                or item.get("endDate")
+            )
+            if close_time:
+                try:
+                    if isinstance(close_time, (int, float)):
+                        from datetime import timezone
+
+                        dt = datetime.fromtimestamp(close_time, tz=timezone.utc)
+                        item["resolution_date"] = dt.strftime("%Y-%m-%d %H:%M UTC")
+                    else:
+                        item["resolution_date"] = str(close_time)
+                except Exception:
+                    item["resolution_date"] = str(close_time)
         return items
 
     # =========================================================================

sakit/utils/dflow.py

@@ -258,6 +258,64 @@ def test_medium_safety_score(self):
         assert result.score == "MEDIUM"
         assert result.recommendation == "CAUTION"
 
+    def test_kalshi_market_with_clear_date_gets_high_score(self):
+        """Kalshi markets (KX prefix) with clear resolution date should get HIGH score."""
+        market = {
+            "ticker": "KXTRUMPOUT-26-TRUMP",
+            "volume": 500,  # Would normally be low
+            "liquidity": 100,  # Would normally be low
+            "closeTime": int(time.time()) + 86400 * 30,  # 30 days from now
+            "rulesPrimary": "short",  # Would normally trigger warning
+        }
+        result = calculate_safety_score(market)
+        assert result.score == "HIGH"
+        assert result.recommendation == "PROCEED"
+        assert len(result.warnings) == 0
+
+    def test_polymarket_with_clear_date_gets_high_score(self):
+        """Polymarket (POLY prefix) with clear resolution date should get HIGH score."""
+        market = {
+            "ticker": "POLY-ELECTION-2024",
+            "volume": 500,
+            "liquidity": 100,
+            "expirationTime": int(time.time()) + 86400 * 30,
+            "rulesPrimary": "short",
+        }
+        result = calculate_safety_score(market)
+        assert result.score == "HIGH"
+        assert result.recommendation == "PROCEED"
+
+    def test_verified_platform_without_date_still_checks_other_factors(self):
+        """Verified platform without clear date should still check other factors."""
+        market = {
+            "ticker": "KXSOMETHING",
+            "volume": 500,  # Low volume
+            "liquidity": 100,  # Low liquidity
+            # No closeTime or expirationTime
+            "rulesPrimary": "short",
+        }
+        result = calculate_safety_score(market)
+        # Without clear date, should not auto-pass
+        assert result.score != "HIGH" or len(result.warnings) > 0
+
+    def test_objective_category_with_date_gets_boost(self):
+        """Objective category (e.g., politics) with clear date should get score boost."""
+        # This market would normally be MEDIUM but gets boosted
+        market = {
+            "ticker": "SOMEMARKET",
+            "category": "politics",
+            "volume": 5000,  # Moderate volume (-10)
+            "liquidity": 1500,  # Moderate liquidity (-10)
+            "closeTime": int(time.time()) + 86400 * 30,  # Has clear date
+            "rulesPrimary": "x" * 100,  # Clear rules
+            "seriesTicker": "UNKNOWN-SERIES",  # Unknown series (-15)
+            # Without boost: 100 - 10 - 10 - 15 = 65 (MEDIUM)
+            # With boost: 65 + 15 = 80 (HIGH)
+        }
+        result = calculate_safety_score(market)
+        assert result.score == "HIGH"
+        assert result.recommendation == "PROCEED"
+
 
 # =============================================================================
 # TOOL SCHEMA TESTS
@@ -899,6 +957,79 @@ def test_add_safety_scores(self):
         assert result[0]["safety"]["score"] in ["HIGH", "MEDIUM", "LOW"]
         assert "safety" in result[1]
 
+    def test_add_safety_scores_with_resolution_date_int(self):
+        """Resolution date should be formatted from int timestamp."""
+        client = DFlowPredictionClient()
+
+        items = [
+            {
+                "ticker": "A",
+                "volume": 50000,
+                "liquidity": 10000,
+                "rulesPrimary": "x" * 100,
+                "closeTime": 1735689600,  # 2025-01-01 00:00:00 UTC
+            },
+        ]
+
+        result = client._add_safety_scores(items)
+        assert "resolution_date" in result[0]
+        assert "2025-01-01" in result[0]["resolution_date"]
+        assert "UTC" in result[0]["resolution_date"]
+
+    def test_add_safety_scores_with_resolution_date_string(self):
+        """Resolution date should handle string date."""
+        client = DFlowPredictionClient()
+
+        items = [
+            {
+                "ticker": "A",
+                "volume": 50000,
+                "liquidity": 10000,
+                "rulesPrimary": "x" * 100,
+                "closeTime": "2025-01-01T00:00:00Z",  # String format
+            },
+        ]
+
+        result = client._add_safety_scores(items)
+        assert "resolution_date" in result[0]
+        assert result[0]["resolution_date"] == "2025-01-01T00:00:00Z"
+
+    def test_add_safety_scores_no_resolution_date(self):
+        """Items without resolution date should not have resolution_date field."""
+        client = DFlowPredictionClient()
+
+        items = [
+            {
+                "ticker": "A",
+                "volume": 50000,
+                "liquidity": 10000,
+                "rulesPrimary": "x" * 100,
+                # No closeTime, expirationTime, or endDate
+            },
+        ]
+
+        result = client._add_safety_scores(items)
+        assert "resolution_date" not in result[0]
+
+    def test_add_safety_scores_with_invalid_timestamp(self):
+        """Invalid timestamp should fallback to string representation."""
+        client = DFlowPredictionClient()
+
+        items = [
+            {
+                "ticker": "A",
+                "volume": 50000,
+                "liquidity": 10000,
+                "rulesPrimary": "x" * 100,
+                "closeTime": -99999999999999,  # Invalid timestamp
+            },
+        ]
+
+        result = client._add_safety_scores(items)
+        assert "resolution_date" in result[0]
+        # Should fallback to string of the invalid value
+        assert "-99999999999999" in result[0]["resolution_date"]
+
 
 # =============================================================================
 # BLOCKING EXECUTION TESTS