v15.2.0 (#56)

Author: truemagic-coder

.coverage

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

pyproject.toml

@@ -537,26 +537,25 @@ async def sign_and_send(tx_b64: str) -> str:
 
             elif action == "positions":
                 # For positions, we need to check the user's token balances
-                # This requires querying on-chain data for outcome token holdings
                 if not self._private_key:
                     return {"status": "error", "message": "private_key not configured"}
 
+                if not self._rpc_url:
+                    return {
+                        "status": "error",
+                        "message": "rpc_url must be configured to query positions",
+                    }
+
                 keypair = Keypair.from_base58_string(self._private_key)
                 user_pubkey = str(keypair.pubkey())
 
-                # Get all outcome mints to identify which tokens are prediction outcomes
-                outcome_mints = await client.get_outcome_mints()
-
-                return {
-                    "status": "success",
-                    "message": "Position tracking requires on-chain token balance queries. "
-                    "Use a wallet tool to check balances for outcome token mints.",
-                    "user_wallet": user_pubkey,
-                    "outcome_mint_count": len(outcome_mints)
-                    if isinstance(outcome_mints, list)
-                    else "see data",
-                    "hint": "Query token balances for mints from outcome_mints to find positions.",
-                }
+                # Query positions via RPC + DFlow outcome mints
+                positions_result = await client.get_positions(
+                    wallet_address=user_pubkey,
+                    rpc_url=self._rpc_url,
+                )
+
+                return positions_result
 
             else:
                 return {"status": "error", "message": f"Unknown action: {action}"}

sakit/dflow_prediction.py

@@ -832,13 +832,19 @@ async def sign_and_send(tx_b64: str) -> str:  # pragma: no cover
                     }
 
             elif action == "positions":
-                # For positions, we need the user's wallet address
+                # For positions, we need the user's wallet address and RPC
                 if not privy_user_id:
                     return {
                         "status": "error",
                         "message": "privy_user_id is required for positions action",
                     }
 
+                if not self._rpc_url:
+                    return {
+                        "status": "error",
+                        "message": "rpc_url must be configured to query positions",
+                    }
+
                 # Validate Privy configuration
                 if not self._privy_app_id or not self._privy_app_secret:
                     return {
@@ -857,19 +863,13 @@ async def sign_and_send(tx_b64: str) -> str:  # pragma: no cover
 
                 wallet_address = wallet["public_key"]
 
-                # Get all outcome mints to identify which tokens are prediction outcomes
-                outcome_mints = await client.get_outcome_mints()
-
-                return {
-                    "status": "success",
-                    "message": "Position tracking requires on-chain token balance queries. "
-                    "Use a wallet tool to check balances for outcome token mints.",
-                    "user_wallet": wallet_address,
-                    "outcome_mint_count": len(outcome_mints)
-                    if isinstance(outcome_mints, list)
-                    else "see data",
-                    "hint": "Query token balances for mints from outcome_mints to find positions.",
-                }
+                # Query positions via RPC + DFlow outcome mints
+                positions_result = await client.get_positions(
+                    wallet_address=wallet_address,
+                    rpc_url=self._rpc_url,
+                )
+
+                return positions_result
 
             else:
                 return {"status": "error", "message": f"Unknown action: {action}"}

sakit/privy_dflow_prediction.py

@@ -1169,3 +1169,127 @@ async def execute_prediction_order_blocking(
                 price_impact_pct=None,
                 error=str(e),
             )
+
+    async def get_positions(
+        self,
+        wallet_address: str,
+        rpc_url: str,
+    ) -> Dict[str, Any]:
+        """
+        Get prediction market positions for a wallet.
+
+        Queries token accounts via RPC and cross-references with DFlow outcome mints
+        to identify prediction market positions.
+
+        Args:
+            wallet_address: Solana wallet address to check
+            rpc_url: RPC endpoint URL
+
+        Returns:
+            Dict with positions list and summary
+        """
+        # Get all outcome mints from DFlow
+        outcome_mints = await self.get_outcome_mints()
+
+        # Query wallet token accounts via RPC
+        token_accounts = await _get_token_accounts(rpc_url, wallet_address)
+
+        if "error" in token_accounts:
+            return {
+                "status": "error",
+                "message": f"Failed to query token accounts: {token_accounts['error']}",
+            }
+
+        # Cross-reference to find prediction positions
+        positions = []
+
+        for account in token_accounts.get("accounts", []):
+            mint = account.get("mint")
+            if mint and mint in outcome_mints:
+                market_info = outcome_mints[mint]
+                amount = account.get("amount", "0")
+                ui_amount = account.get("uiAmount", 0)
+
+                # Only include if they have a balance
+                if ui_amount > 0:
+                    positions.append(
+                        {
+                            "mint": mint,
+                            "ticker": market_info.get(
+                                "market", market_info.get("ticker", "unknown")
+                            ),
+                            "side": market_info.get("side", "unknown").upper(),
+                            "amount": amount,
+                            "ui_amount": ui_amount,
+                            "decimals": account.get("decimals", 6),
+                        }
+                    )
+
+        return {
+            "status": "success",
+            "wallet": wallet_address,
+            "position_count": len(positions),
+            "positions": positions,
+            "hint": "Each position represents outcome tokens. Sell to exit or hold until resolution."
+            if positions
+            else "No prediction market positions found.",
+        }
+
+
+async def _get_token_accounts(rpc_url: str, wallet_address: str) -> Dict[str, Any]:
+    """
+    Get all SPL token accounts for a wallet via RPC.
+
+    Args:
+        rpc_url: RPC endpoint URL
+        wallet_address: Wallet public key
+
+    Returns:
+        Dict with 'accounts' list or 'error' on failure
+    """
+    # Token Program ID
+    TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "getTokenAccountsByOwner",
+        "params": [
+            wallet_address,
+            {"programId": TOKEN_PROGRAM_ID},
+            {"encoding": "jsonParsed"},
+        ],
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(rpc_url, json=payload)
+            if response.status_code != 200:
+                return {"error": f"RPC error: {response.status_code}"}
+
+            data = response.json()
+            if "error" in data:
+                return {"error": f"RPC error: {data['error']}"}
+
+            result = data.get("result", {}).get("value", [])
+
+            accounts = []
+            for item in result:
+                parsed = item.get("account", {}).get("data", {}).get("parsed", {})
+                info = parsed.get("info", {})
+                token_amount = info.get("tokenAmount", {})
+
+                accounts.append(
+                    {
+                        "mint": info.get("mint"),
+                        "amount": token_amount.get("amount", "0"),
+                        "uiAmount": float(token_amount.get("uiAmount", 0) or 0),
+                        "decimals": token_amount.get("decimals", 0),
+                    }
+                )
+
+            return {"accounts": accounts}
+
+    except Exception as e:
+        logger.exception("Failed to get token accounts")
+        return {"error": str(e)}