v14.0.2 (#28)

Author: truemagic-coder

pyproject.toml

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

sakit/utils/recurring.py

@@ -97,32 +97,50 @@ async def create_order(
             order_count: Total number of orders to execute
             frequency: Time between each order in seconds (as string, e.g., "3600" for hourly)
             payer: Optional payer wallet address for gasless (defaults to user)
-            min_out_amount: Optional minimum output amount per order
-            max_out_amount: Optional maximum output amount per order
+            min_out_amount: Optional minimum output amount per order (as price, not amount)
+            max_out_amount: Optional maximum output amount per order (as price, not amount)
             start_at: Optional start time in unix seconds (as string)
 
         Returns:
             RecurringOrderResponse with transaction to sign
         """
+        # Build the time-based order params per Jupiter API spec
+        time_params: Dict[str, Any] = {
+            "inAmount": int(in_amount),
+            "numberOfOrders": int(order_count),
+            "interval": int(frequency),
+            "minPrice": None,
+            "maxPrice": None,
+            "startAt": None,
+        }
+
+        # Handle optional price bounds
+        if min_out_amount:
+            try:
+                time_params["minPrice"] = float(min_out_amount)
+            except (ValueError, TypeError):
+                pass
+        if max_out_amount:
+            try:
+                time_params["maxPrice"] = float(max_out_amount)
+            except (ValueError, TypeError):
+                pass
+        if start_at:
+            try:
+                time_params["startAt"] = int(start_at)
+            except (ValueError, TypeError):
+                pass
+
         body = {
             "user": user,
             "payer": payer or user,
             "inputMint": input_mint,
             "outputMint": output_mint,
             "params": {
-                "depositAmount": in_amount,
-                "orderCount": order_count,
-                "frequency": frequency,
+                "time": time_params,
             },
         }
 
-        if min_out_amount:
-            body["params"]["minOutAmount"] = min_out_amount
-        if max_out_amount:
-            body["params"]["maxOutAmount"] = max_out_amount
-        if start_at:
-            body["params"]["startAt"] = start_at
-
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 response = await client.post(

tests/test_recurring_utils.py

@@ -112,7 +112,7 @@ async def test_create_order_with_payer(self, recurring_client):
 
     @pytest.mark.asyncio
     async def test_create_order_with_min_max_amounts(self, recurring_client):
-        """Should include minOutAmount and maxOutAmount when provided."""
+        """Should include minPrice and maxPrice when provided."""
         mock_response = {
             "order": "dcaorder123",
             "transaction": "base64encodedtx==",
@@ -140,9 +140,10 @@ async def test_create_order_with_min_max_amounts(self, recurring_client):
 
             call_args = mock_instance.post.call_args
             payload = call_args.kwargs.get("json") or call_args[1].get("json")
-            # min/max amounts are in nested params object
-            assert payload.get("params", {}).get("minOutAmount") == "90000"
-            assert payload.get("params", {}).get("maxOutAmount") == "110000"
+            # minPrice/maxPrice are in nested params.time object (converted to float)
+            time_params = payload.get("params", {}).get("time", {})
+            assert time_params.get("minPrice") == 90000.0
+            assert time_params.get("maxPrice") == 110000.0
 
     @pytest.mark.asyncio
     async def test_create_order_api_error(self, recurring_client):