v14.1.2 (#33)

Author: truemagic-coder

.coverage

@@ -365,13 +365,16 @@ config = {
 
 This plugin enables Solana Agent to swap tokens using DFlow's Swap API with Privy delegated wallets. DFlow offers faster swaps compared to Jupiter Ultra with competitive rates and supports platform fees for monetization.
 
+Transactions are signed via Privy and sent via your configured RPC (Helius recommended) for reliable blockhash handling and priority fees.
+
 ```python
 config = {
     "tools": {
         "privy_dflow_swap": {
             "app_id": "your-privy-app-id", # Required - your Privy application ID
             "app_secret": "your-privy-app-secret", # Required - your Privy application secret
             "signing_key": "wallet-auth:your-signing-key", # Required - your Privy wallet authorization signing key
+            "rpc_url": "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY", # Required - Helius recommended for priority fees
             "platform_fee_bps": 50, # Optional - platform fee in basis points (e.g., 50 = 0.5%)
             "fee_account": "your-fee-token-account", # Optional - token account to receive platform fees
             "payer_private_key": "payer-private-key", # Optional - for gasless/sponsored transactions
@@ -384,8 +387,12 @@ config = {
 - **Fast Swaps**: DFlow typically executes faster than Jupiter Ultra
 - **Platform Fees**: Collect fees on swaps (in basis points) paid to your fee account
 - **Privy Delegated Wallets**: Seamless user experience with embedded wallets
+- **Helius Priority Fees**: Uses Helius priority fee estimation for reliable transaction landing
 - **Gasless Transactions**: Optionally sponsor gas fees for users via `payer_private_key`
 
+**RPC URL (Required):**
+Helius RPC is strongly recommended (`https://mainnet.helius-rpc.com/?api-key=YOUR_KEY`). Helius provides priority fee estimation and better blockhash handling, which significantly improves transaction success rates. Get a free API key at [helius.dev](https://helius.dev).
+
 **Platform Fee Setup:**
 To collect platform fees, you need to create a token account for the output token and provide it as `fee_account`. The `platform_fee_bps` specifies the fee amount (e.g., 50 = 0.5%).
 

README.md

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

pyproject.toml

@@ -6,6 +6,9 @@
 
 DFlow offers faster swaps compared to Jupiter Ultra with similar liquidity
 and supports platform fees for monetization.
+
+Transactions are signed via Privy's signTransaction and sent via Helius RPC
+for priority fees and reliable blockhash handling.
 """
 
 import base64
@@ -21,6 +24,7 @@
 from solders.message import to_bytes_versioned  # type: ignore
 
 from sakit.utils.dflow import DFlowSwap
+from sakit.utils.wallet import send_raw_transaction_with_priority
 
 logger = logging.getLogger(__name__)
 
@@ -127,27 +131,27 @@ async def _get_privy_embedded_wallet(  # pragma: no cover
         return None
 
 
-async def _privy_sign_and_send_transaction(  # pragma: no cover
+async def _privy_sign_transaction(  # pragma: no cover
     privy_client: AsyncPrivyAPI,
     wallet_id: str,
     encoded_tx: str,
     signing_key: str,
 ) -> Dict[str, Any]:
-    """Sign and send a Solana transaction via Privy using the official SDK.
+    """Sign a Solana transaction via Privy using the official SDK.
 
-    Uses Privy's signAndSendTransaction RPC method which handles both
-    signing with the delegated wallet and broadcasting to Solana in one call.
+    Uses Privy's signTransaction RPC method to sign the transaction without
+    broadcasting. The signed transaction should then be sent via Helius or
+    another RPC provider for reliable blockhash handling.
 
     Returns:
-        Dict with 'hash' (transaction signature) on success, or error details.
+        Dict with 'signed_transaction' (base64 encoded) on success, or error details.
     """
     try:
         pkcs8_key = _convert_key_to_pkcs8_pem(signing_key)
 
-        # IMPORTANT: signAndSendTransaction requires caip2 for Solana mainnet
         url = f"https://api.privy.io/v1/wallets/{wallet_id}/rpc"
         body = {
-            "method": "signAndSendTransaction",
+            "method": "signTransaction",
             "params": {"transaction": encoded_tx, "encoding": "base64"},
             "caip2": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
             "chain_type": "solana",
@@ -163,25 +167,32 @@ async def _privy_sign_and_send_transaction(  # pragma: no cover
 
         result = await privy_client.wallets.rpc(
             wallet_id=wallet_id,
-            method="signAndSendTransaction",
+            method="signTransaction",
             params={"transaction": encoded_tx, "encoding": "base64"},
             caip2="solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
             chain_type="solana",
             privy_authorization_signature=auth_signature,
         )
 
-        # Extract the transaction signature (hash) from the result
+        # Extract the signed transaction from the result
         if result.data:
-            return {
-                "success": True,
-                "hash": getattr(result.data, "hash", None),
-            }
-        return {"success": False, "error": "No data returned from Privy"}
+            signed_tx = getattr(result.data, "signed_transaction", None)
+            if signed_tx:
+                return {"success": True, "signed_transaction": signed_tx}
+            # Some SDK versions return the transaction directly
+            tx = getattr(result.data, "transaction", None)
+            if tx:
+                return {"success": True, "signed_transaction": tx}
+        return {"success": False, "error": "No signed transaction returned from Privy"}
     except Exception as e:
-        logger.error(f"Privy API error signing and sending transaction: {e}")
+        logger.error(f"Privy API error signing transaction: {e}")
         return {"success": False, "error": str(e)}
 
 
+# Default RPC URL if none configured
+DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com"
+
+
 class PrivyDFlowSwapTool(AutoTool):
     """Fast token swaps using DFlow API with Privy embedded wallets."""
 
@@ -202,6 +213,7 @@ def __init__(self, registry: Optional[ToolRegistry] = None):
         self._fee_account: Optional[str] = None
         self._referral_account: Optional[str] = None
         self._payer_private_key: Optional[str] = None
+        self._rpc_url: Optional[str] = None
 
     def get_schema(self) -> Dict[str, Any]:
         return {
@@ -243,6 +255,8 @@ def configure(self, config: Dict[str, Any]) -> None:
         self._fee_account = tool_cfg.get("fee_account")
         self._referral_account = tool_cfg.get("referral_account")
         self._payer_private_key = tool_cfg.get("payer_private_key")
+        # RPC URL for sending transactions (Helius recommended for priority fees)
+        self._rpc_url = tool_cfg.get("rpc_url")
 
     async def execute(  # pragma: no cover
         self,
@@ -330,20 +344,39 @@ async def execute(  # pragma: no cover
                         "utf-8"
                     )
 
-                # Sign and send via Privy (uses signAndSendTransaction RPC method)
-                send_result = await _privy_sign_and_send_transaction(
+                # Sign via Privy (signTransaction only, not signAndSendTransaction)
+                sign_result = await _privy_sign_transaction(
                     privy_client,
                     wallet_id,
                     tx_to_sign,
                     self._signing_key,
                 )
 
+                if not sign_result.get("success"):
+                    error_msg = sign_result.get("error", "Failed to sign transaction")
+                    return {"status": "error", "message": error_msg}
+
+                signed_tx_base64 = sign_result.get("signed_transaction")
+                if not signed_tx_base64:
+                    return {
+                        "status": "error",
+                        "message": "No signed transaction returned from Privy.",
+                    }
+
+                # Send via RPC (Helius recommended for priority fees)
+                rpc_url = self._rpc_url or DEFAULT_RPC_URL
+                tx_bytes = base64.b64decode(signed_tx_base64)
+                send_result = await send_raw_transaction_with_priority(
+                    rpc_url=rpc_url,
+                    tx_bytes=tx_bytes,
+                )
+
                 if send_result.get("success"):
-                    signature = send_result.get("hash")
+                    signature = send_result.get("signature")
                     if not signature:
                         return {
                             "status": "error",
-                            "message": "No transaction signature returned from Privy.",
+                            "message": "No transaction signature returned.",
                         }
 
                     return {
@@ -376,7 +409,7 @@ async def execute(  # pragma: no cover
                     return {
                         "status": "error",
                         "message": send_result.get(
-                            "error", "Failed to sign and send transaction via Privy."
+                            "error", "Failed to send transaction."
                         ),
                     }
 

sakit/privy_dflow_swap.py

@@ -1,6 +1,7 @@
 from typing import Dict, List, Optional
 import httpx
 import nacl.signing
+import logging
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Confirmed
 from solana.rpc.types import TxOpts
@@ -11,6 +12,8 @@
 from solders.signature import Signature
 from solders.pubkey import Pubkey
 
+logger = logging.getLogger(__name__)
+
 
 class SolanaTransaction:
     """Transaction parameters for Solana."""
@@ -110,3 +113,98 @@ async def get_priority_fee_estimate_helius(  # pragma: no cover
             if "error" in result:
                 raise RuntimeError(f"Fee estimation failed: {result['error']}")
             return int(result["result"]["priorityFeeEstimate"])
+
+
+async def send_raw_transaction_with_priority(  # pragma: no cover
+    rpc_url: str,
+    tx_bytes: bytes,
+    skip_preflight: bool = True,
+    max_retries: int = 5,
+) -> Dict[str, any]:
+    """
+    Send a raw transaction to Solana RPC, with Helius priority fee logging if applicable.
+
+    This is the standard way to send pre-signed transactions (e.g., from DFlow, Jupiter)
+    through Helius or any Solana RPC endpoint.
+
+    Args:
+        rpc_url: The RPC endpoint URL (Helius recommended for priority fees)
+        tx_bytes: The serialized signed transaction bytes
+        skip_preflight: Skip preflight simulation (default True for pre-signed txs)
+        max_retries: Number of retries for the RPC call
+
+    Returns:
+        Dict with 'success' and 'signature' on success, or 'error' on failure.
+    """
+    try:
+        client = AsyncClient(rpc_url)
+        try:
+            # Get priority fee estimate if using Helius (for logging)
+            if "helius" in rpc_url.lower():
+                try:
+                    import base64
+
+                    tx_base64 = base64.b64encode(tx_bytes).decode("utf-8")
+                    async with httpx.AsyncClient() as http_client:
+                        payload = {
+                            "jsonrpc": "2.0",
+                            "id": "1",
+                            "method": "getPriorityFeeEstimate",
+                            "params": [
+                                {
+                                    "transaction": tx_base64,
+                                    "options": {"recommended": True},
+                                }
+                            ],
+                        }
+                        response = await http_client.post(rpc_url, json=payload)
+                        if response.status_code == 200:
+                            result = response.json()
+                            if "result" in result:
+                                priority_fee = result["result"].get(
+                                    "priorityFeeEstimate", 0
+                                )
+                                logger.info(
+                                    f"Helius priority fee estimate: {priority_fee}"
+                                )
+                except Exception as fee_error:
+                    logger.debug(f"Could not get priority fee estimate: {fee_error}")
+
+            # Send the transaction
+            result = await client.send_raw_transaction(
+                tx_bytes,
+                opts=TxOpts(
+                    skip_preflight=skip_preflight,
+                    preflight_commitment=Confirmed,
+                    max_retries=max_retries,
+                ),
+            )
+
+            signature = str(result.value)
+            logger.info(f"Transaction sent: {signature}")
+
+            # Confirm the transaction
+            try:
+                confirmation = await client.confirm_transaction(
+                    result.value,
+                    commitment=Confirmed,
+                    sleep_seconds=0.5,
+                    last_valid_block_height=None,
+                )
+                if confirmation.value and confirmation.value[0].err:
+                    return {
+                        "success": False,
+                        "error": f"Transaction failed: {confirmation.value[0].err}",
+                    }
+            except Exception as confirm_error:
+                logger.debug(f"Could not confirm transaction: {confirm_error}")
+                # Still return success since transaction was sent
+
+            return {"success": True, "signature": signature}
+
+        finally:
+            await client.close()
+
+    except Exception as e:
+        logger.error(f"RPC error sending transaction: {e}")
+        return {"success": False, "error": str(e)}