nado-protocol 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

nado_protocol/client/apis/market/execute.py

@@ -1,3 +1,4 @@
+from typing import Optional, List
 from nado_protocol.engine_client.types.execute import (
     BurnNlpParams,
     CancelAndPlaceParams,
@@ -16,6 +17,7 @@ from nado_protocol.trigger_client.types.execute import (
 )
 from nado_protocol.utils.exceptions import MissingTriggerClient
 from nado_protocol.utils.subaccount import Subaccount
+from nado_protocol.utils.expiration import OrderType
 
 
 class MarketExecuteAPI(NadoBaseAPI):
@@ -174,3 +176,147 @@ class MarketExecuteAPI(NadoBaseAPI):
         if self.context.trigger_client is None:
             raise MissingTriggerClient()
         return self.context.trigger_client.cancel_product_trigger_orders(params)
+
+    def place_twap_order(
+        self,
+        product_id: int,
+        price_x18: str,
+        total_amount_x18: str,
+        times: int,
+        slippage_frac: float,
+        interval_seconds: int,
+        sender: Optional[str] = None,
+        subaccount_owner: Optional[str] = None,
+        subaccount_name: str = "default",
+        expiration: Optional[int] = None,
+        nonce: Optional[int] = None,
+        custom_amounts_x18: Optional[List[str]] = None,
+        reduce_only: bool = False,
+        spot_leverage: Optional[bool] = None,
+        id: Optional[int] = None,
+    ) -> ExecuteResponse:
+        """
+        Place a TWAP (Time-Weighted Average Price) order.
+
+        This is a convenience method that creates a TWAP trigger order with the specified parameters.
+
+        Args:
+            product_id (int): The product ID for the order.
+            price_x18 (str): The limit price multiplied by 1e18.
+            total_amount_x18 (str): The total amount to trade multiplied by 1e18 (signed, negative for sell).
+            times (int): Number of TWAP executions (1-500).
+            slippage_frac (float): Slippage tolerance as a fraction (e.g., 0.01 for 1%).
+            interval_seconds (int): Time interval between executions in seconds.
+            sender (Optional[str]): The sender address (32 bytes hex or SubaccountParams). If provided, takes precedence over subaccount_owner/subaccount_name.
+            subaccount_owner (Optional[str]): The subaccount owner address. If not provided, uses client's signer address. Ignored if sender is provided.
+            subaccount_name (str): The subaccount name. Defaults to "default". Ignored if sender is provided.
+            expiration (Optional[int]): Order expiration timestamp. If not provided, calculated as min(((times - 1) * interval_seconds) + 1 hour, 25 hours) from now.
+            nonce (Optional[int]): Order nonce. If not provided, will be auto-generated.
+            custom_amounts_x18 (Optional[List[str]]): Custom amounts for each execution multiplied by 1e18.
+            reduce_only (bool): Whether this is a reduce-only order. Defaults to False.
+            spot_leverage (Optional[bool]): Whether to use spot leverage.
+            id (Optional[int]): Optional order ID.
+
+        Returns:
+            ExecuteResponse: The response from placing the TWAP order.
+
+        Raises:
+            MissingTriggerClient: If trigger client is not configured.
+        """
+        if self.context.trigger_client is None:
+            raise MissingTriggerClient()
+        return self.context.trigger_client.place_twap_order(
+            product_id=product_id,
+            price_x18=price_x18,
+            total_amount_x18=total_amount_x18,
+            times=times,
+            slippage_frac=slippage_frac,
+            interval_seconds=interval_seconds,
+            sender=sender,
+            subaccount_owner=subaccount_owner,
+            subaccount_name=subaccount_name,
+            expiration=expiration,
+            nonce=nonce,
+            custom_amounts_x18=custom_amounts_x18,
+            reduce_only=reduce_only,
+            spot_leverage=spot_leverage,
+            id=id,
+        )
+
+    def place_price_trigger_order(
+        self,
+        product_id: int,
+        price_x18: str,
+        amount_x18: str,
+        trigger_price_x18: str,
+        trigger_type: str,
+        sender: Optional[str] = None,
+        subaccount_owner: Optional[str] = None,
+        subaccount_name: str = "default",
+        expiration: Optional[int] = None,
+        nonce: Optional[int] = None,
+        reduce_only: bool = False,
+        order_type: OrderType = OrderType.DEFAULT,
+        spot_leverage: Optional[bool] = None,
+        id: Optional[int] = None,
+        dependency: Optional[dict] = None,
+    ) -> ExecuteResponse:
+        """
+        Place a price trigger order.
+
+        This is a convenience method that creates a price trigger order with the specified parameters.
+
+        Args:
+            product_id (int): The product ID for the order.
+            price_x18 (str): The limit price multiplied by 1e18.
+            amount_x18 (str): The amount to trade multiplied by 1e18 (signed, negative for sell).
+            trigger_price_x18 (str): The trigger price multiplied by 1e18.
+            trigger_type (str): Type of price trigger - one of:
+                "last_price_above", "last_price_below",
+                "oracle_price_above", "oracle_price_below",
+                "mid_price_above", "mid_price_below".
+            sender (Optional[str]): The sender address (32 bytes hex or SubaccountParams). If provided, takes precedence over subaccount_owner/subaccount_name.
+            subaccount_owner (Optional[str]): The subaccount owner address. If not provided, uses client's signer address. Ignored if sender is provided.
+            subaccount_name (str): The subaccount name. Defaults to "default". Ignored if sender is provided.
+            expiration (Optional[int]): Order expiration timestamp. If not provided, defaults to 7 days from now.
+            nonce (Optional[int]): Order nonce. If not provided, will be auto-generated.
+            reduce_only (bool): Whether this is a reduce-only order. Defaults to False.
+            order_type (OrderType): Order execution type (DEFAULT, IOC, FOK, POST_ONLY). Defaults to DEFAULT.
+            spot_leverage (Optional[bool]): Whether to use spot leverage.
+            id (Optional[int]): Optional order ID.
+            dependency (Optional[dict]): Optional dependency trigger dict with 'digest' and 'on_partial_fill' keys.
+
+        Returns:
+            ExecuteResponse: The response from placing the price trigger order.
+
+        Raises:
+            MissingTriggerClient: If trigger client is not configured.
+            ValueError: If trigger_type is not supported.
+        """
+        if self.context.trigger_client is None:
+            raise MissingTriggerClient()
+
+        # Convert dict to Dependency if provided
+        dependency_obj = None
+        if dependency is not None:
+            from nado_protocol.trigger_client.types.models import Dependency
+
+            dependency_obj = Dependency.parse_obj(dependency)
+
+        return self.context.trigger_client.place_price_trigger_order(
+            product_id=product_id,
+            price_x18=price_x18,
+            amount_x18=amount_x18,
+            trigger_price_x18=trigger_price_x18,
+            trigger_type=trigger_type,
+            sender=sender,
+            subaccount_owner=subaccount_owner,
+            subaccount_name=subaccount_name,
+            expiration=expiration,
+            nonce=nonce,
+            reduce_only=reduce_only,
+            order_type=order_type,
+            spot_leverage=spot_leverage,
+            id=id,
+            dependency=dependency_obj,
+        )

nado_protocol/trigger_client/execute.py

@@ -1,6 +1,6 @@
 import requests
 from functools import singledispatchmethod
-from typing import Union
+from typing import Union, Optional, List, cast
 from nado_protocol.contracts.types import NadoExecuteType
 from nado_protocol.trigger_client.types.execute import (
     TriggerExecuteParams,
@@ -16,8 +16,26 @@ from nado_protocol.utils.exceptions import (
     BadStatusCodeException,
     ExecuteFailedException,
 )
-from nado_protocol.utils.execute import NadoBaseExecute
+from nado_protocol.utils.execute import NadoBaseExecute, OrderParams
 from nado_protocol.utils.model import NadoBaseModel, is_instance_of_union
+from nado_protocol.utils.twap import create_twap_order
+from nado_protocol.utils.order import build_appendix, OrderAppendixTriggerType
+from nado_protocol.utils.expiration import OrderType, get_expiration_timestamp
+from nado_protocol.utils.nonce import gen_order_nonce
+from nado_protocol.utils.subaccount import SubaccountParams
+from nado_protocol.utils.bytes32 import subaccount_to_hex
+from nado_protocol.trigger_client.types.models import (
+    PriceTrigger,
+    PriceTriggerData,
+    LastPriceAbove,
+    LastPriceBelow,
+    OraclePriceAbove,
+    OraclePriceBelow,
+    MidPriceAbove,
+    MidPriceBelow,
+    PriceRequirement,
+    Dependency,
+)
 
 
 class TriggerExecuteClient(NadoBaseExecute):
@@ -95,6 +113,213 @@ class TriggerExecuteClient(NadoBaseExecute):
         )
         return self.execute(params)
 
+    def place_twap_order(
+        self,
+        product_id: int,
+        price_x18: str,
+        total_amount_x18: str,
+        times: int,
+        slippage_frac: float,
+        interval_seconds: int,
+        sender: Optional[Union[str, SubaccountParams]] = None,
+        subaccount_owner: Optional[str] = None,
+        subaccount_name: str = "default",
+        expiration: Optional[int] = None,
+        nonce: Optional[int] = None,
+        custom_amounts_x18: Optional[List[str]] = None,
+        reduce_only: bool = False,
+        spot_leverage: Optional[bool] = None,
+        id: Optional[int] = None,
+    ) -> ExecuteResponse:
+        """
+        Place a TWAP (Time-Weighted Average Price) order.
+
+        This is a convenience method that creates a TWAP trigger order with the specified parameters.
+
+        Args:
+            product_id (int): The product ID for the order.
+            price_x18 (str): The limit price multiplied by 1e18.
+            total_amount_x18 (str): The total amount to trade multiplied by 1e18 (signed, negative for sell).
+            times (int): Number of TWAP executions (1-500).
+            slippage_frac (float): Slippage tolerance as a fraction (e.g., 0.01 for 1%).
+            interval_seconds (int): Time interval between executions in seconds.
+            sender (Optional[str]): The sender address (32 bytes hex or SubaccountParams). If provided, takes precedence over subaccount_owner/subaccount_name.
+            subaccount_owner (Optional[str]): The subaccount owner address. If not provided, uses client's signer address. Ignored if sender is provided.
+            subaccount_name (str): The subaccount name. Defaults to "default". Ignored if sender is provided.
+            expiration (Optional[int]): Order expiration timestamp. If not provided, calculated as min(((times - 1) * interval_seconds) + 1 hour, 25 hours) from now.
+            nonce (Optional[int]): Order nonce. If not provided, will be auto-generated.
+            custom_amounts_x18 (Optional[List[str]]): Custom amounts for each execution multiplied by 1e18.
+            reduce_only (bool): Whether this is a reduce-only order. Defaults to False.
+            spot_leverage (Optional[bool]): Whether to use spot leverage.
+            id (Optional[int]): Optional order ID.
+
+        Returns:
+            ExecuteResponse: The response from placing the TWAP order.
+        """
+        # Calculate default expiration if not provided
+        # Backend requires: min_expiration <= expiration <= timestamp + 25 hours
+        # Where min_expiration = ((times - 1) * interval) + now
+        if expiration is None:
+            min_duration = (times - 1) * interval_seconds
+            max_duration = 60 * 60 * 25  # 25 hours in seconds
+            # Set expiration to minimum duration + 1 hour buffer, capped at 25 hours
+            buffer_duration = min(min_duration + 60 * 60, max_duration)
+            expiration = get_expiration_timestamp(buffer_duration)
+
+        # Build sender from subaccount parameters if not directly provided
+        sender_value: Union[str, SubaccountParams]
+        if sender is None:
+            sender_value = SubaccountParams(
+                subaccount_owner=subaccount_owner or self.signer.address,
+                subaccount_name=subaccount_name,
+            )
+        else:
+            sender_value = sender
+
+        # Convert sender to hex string if it's SubaccountParams
+        sender_hex: str
+        if isinstance(sender_value, SubaccountParams):
+            sender_hex = subaccount_to_hex(sender_value)
+        else:
+            sender_hex = sender_value
+
+        params = create_twap_order(
+            product_id=product_id,
+            sender=sender_hex,
+            price_x18=price_x18,
+            total_amount_x18=total_amount_x18,
+            expiration=expiration,
+            nonce=nonce if nonce is not None else gen_order_nonce(),
+            times=times,
+            slippage_frac=slippage_frac,
+            interval_seconds=interval_seconds,
+            custom_amounts_x18=custom_amounts_x18,
+            reduce_only=reduce_only,
+            spot_leverage=spot_leverage,
+            id=id,
+        )
+        return self.place_trigger_order(params)
+
+    def place_price_trigger_order(
+        self,
+        product_id: int,
+        price_x18: str,
+        amount_x18: str,
+        trigger_price_x18: str,
+        trigger_type: str,
+        sender: Optional[Union[str, SubaccountParams]] = None,
+        subaccount_owner: Optional[str] = None,
+        subaccount_name: str = "default",
+        expiration: Optional[int] = None,
+        nonce: Optional[int] = None,
+        reduce_only: bool = False,
+        order_type: OrderType = OrderType.DEFAULT,
+        spot_leverage: Optional[bool] = None,
+        id: Optional[int] = None,
+        dependency: Optional[Dependency] = None,
+    ) -> ExecuteResponse:
+        """
+        Place a price trigger order.
+
+        This is a convenience method that creates a price trigger order with the specified parameters.
+
+        Args:
+            product_id (int): The product ID for the order.
+            price_x18 (str): The limit price multiplied by 1e18.
+            amount_x18 (str): The amount to trade multiplied by 1e18 (signed, negative for sell).
+            trigger_price_x18 (str): The trigger price multiplied by 1e18.
+            trigger_type (str): Type of price trigger - one of:
+                "last_price_above", "last_price_below",
+                "oracle_price_above", "oracle_price_below",
+                "mid_price_above", "mid_price_below".
+            sender (Optional[str]): The sender address (32 bytes hex or SubaccountParams). If provided, takes precedence over subaccount_owner/subaccount_name.
+            subaccount_owner (Optional[str]): The subaccount owner address. If not provided, uses client's signer address. Ignored if sender is provided.
+            subaccount_name (str): The subaccount name. Defaults to "default". Ignored if sender is provided.
+            expiration (Optional[int]): Order expiration timestamp. If not provided, defaults to 7 days from now.
+            nonce (Optional[int]): Order nonce. If not provided, will be auto-generated.
+            reduce_only (bool): Whether this is a reduce-only order. Defaults to False.
+            order_type (OrderType): Order execution type (DEFAULT, IOC, FOK, POST_ONLY). Defaults to DEFAULT.
+            spot_leverage (Optional[bool]): Whether to use spot leverage.
+            id (Optional[int]): Optional order ID.
+            dependency (Optional[Dependency]): Optional dependency trigger. If provided, this order will trigger
+                when the specified order (by digest) is filled. The dependency includes:
+                - digest (str): The digest of the order to depend on
+                - on_partial_fill (bool): Whether to trigger on partial fill (True) or only on full fill (False)
+
+        Returns:
+            ExecuteResponse: The response from placing the price trigger order.
+
+        Raises:
+            ValueError: If trigger_type is not supported.
+        """
+        # Create the appropriate price requirement based on trigger type
+        price_requirement: PriceRequirement
+        if trigger_type == "last_price_above":
+            price_requirement = LastPriceAbove(last_price_above=trigger_price_x18)
+        elif trigger_type == "last_price_below":
+            price_requirement = LastPriceBelow(last_price_below=trigger_price_x18)
+        elif trigger_type == "oracle_price_above":
+            price_requirement = OraclePriceAbove(oracle_price_above=trigger_price_x18)
+        elif trigger_type == "oracle_price_below":
+            price_requirement = OraclePriceBelow(oracle_price_below=trigger_price_x18)
+        elif trigger_type == "mid_price_above":
+            price_requirement = MidPriceAbove(mid_price_above=trigger_price_x18)
+        elif trigger_type == "mid_price_below":
+            price_requirement = MidPriceBelow(mid_price_below=trigger_price_x18)
+        else:
+            raise ValueError(
+                f"Unsupported trigger_type: {trigger_type}. "
+                f"Supported types: ['last_price_above', 'last_price_below', 'oracle_price_above', 'oracle_price_below', 'mid_price_above', 'mid_price_below']"
+            )
+
+        trigger = PriceTrigger(
+            price_trigger=PriceTriggerData(
+                price_requirement=price_requirement, dependency=dependency
+            )
+        )
+
+        # Build appendix with PRICE trigger type
+        appendix = build_appendix(
+            order_type=order_type,
+            reduce_only=reduce_only,
+            trigger_type=OrderAppendixTriggerType.PRICE,
+        )
+
+        # Default expiration to 7 days if not provided
+        if expiration is None:
+            expiration = get_expiration_timestamp(60 * 60 * 24 * 7)
+
+        # Build sender from subaccount parameters if not directly provided
+        sender_value: Union[str, SubaccountParams]
+        if sender is None:
+            sender_value = SubaccountParams(
+                subaccount_owner=subaccount_owner or self.signer.address,
+                subaccount_name=subaccount_name,
+            )
+        else:
+            sender_value = sender
+
+        order_params = OrderParams(
+            sender=sender_value,
+            priceX18=int(price_x18),
+            amount=int(amount_x18),
+            expiration=expiration,
+            nonce=nonce if nonce is not None else gen_order_nonce(),
+            appendix=appendix,
+        )
+
+        params = PlaceTriggerOrderParams(
+            product_id=product_id,
+            order=order_params,
+            trigger=trigger,
+            signature=None,
+            digest=None,
+            spot_leverage=spot_leverage,
+            id=id,
+        )
+
+        return self.place_trigger_order(params)
+
     def cancel_trigger_orders(
         self, params: CancelTriggerOrdersParams
     ) -> ExecuteResponse:

nado_protocol/trigger_client/query.py

@@ -4,7 +4,11 @@ from nado_protocol.trigger_client.types import TriggerClientOpts
 from nado_protocol.trigger_client.types.query import (
     ListTriggerOrdersParams,
     ListTriggerOrdersRequest,
+    ListTwapExecutionsParams,
+    ListTwapExecutionsRequest,
     TriggerQueryResponse,
+    TriggerQueryParams,
+    TriggerQueryRequest,
 )
 from nado_protocol.utils.exceptions import (
     BadStatusCodeException,
@@ -59,3 +63,18 @@ class TriggerQueryClient(NadoBaseExecute):
             NadoTxType.LIST_TRIGGER_ORDERS, params.tx.dict()
         )
         return self.query(ListTriggerOrdersRequest.parse_obj(params).dict())
+
+    def list_twap_executions(
+        self, params: ListTwapExecutionsParams
+    ) -> TriggerQueryResponse:
+        """
+        List TWAP executions for a specific order digest.
+
+        Args:
+            params (ListTwapExecutionsParams): Parameters containing the order digest.
+
+        Returns:
+            TriggerQueryResponse: Response containing TWAP execution details.
+        """
+        params = ListTwapExecutionsParams.parse_obj(params)
+        return self.query(ListTwapExecutionsRequest.parse_obj(params).dict())

nado_protocol/trigger_client/types/models.py

@@ -1,28 +1,69 @@
-from typing import Optional, Union
+from typing import Optional, Union, List
 from nado_protocol.utils.model import NadoBaseModel
 
 
-class PriceAboveTrigger(NadoBaseModel):
-    price_above: str
+class OraclePriceAbove(NadoBaseModel):
+    oracle_price_above: str
 
 
-class PriceBelowTrigger(NadoBaseModel):
-    price_below: str
+class OraclePriceBelow(NadoBaseModel):
+    oracle_price_below: str
 
 
-class LastPriceAboveTrigger(NadoBaseModel):
+class LastPriceAbove(NadoBaseModel):
     last_price_above: str
 
 
-class LastPriceBelowTrigger(NadoBaseModel):
+class LastPriceBelow(NadoBaseModel):
     last_price_below: str
 
 
-TriggerCriteria = Union[
-    PriceAboveTrigger, PriceBelowTrigger, LastPriceAboveTrigger, LastPriceBelowTrigger
+class MidPriceAbove(NadoBaseModel):
+    mid_price_above: str
+
+
+class MidPriceBelow(NadoBaseModel):
+    mid_price_below: str
+
+
+PriceRequirement = Union[
+    OraclePriceAbove,
+    OraclePriceBelow,
+    LastPriceAbove,
+    LastPriceBelow,
+    MidPriceAbove,
+    MidPriceBelow,
 ]
 
 
+class Dependency(NadoBaseModel):
+    digest: str
+    on_partial_fill: bool
+
+
+class PriceTriggerData(NadoBaseModel):
+    price_requirement: PriceRequirement
+    dependency: Optional[Dependency] = None
+
+
+class TimeTriggerData(NadoBaseModel):
+    """Time-based trigger for TWAP orders."""
+
+    interval: int  # interval in seconds between executions
+    amounts: Optional[List[str]] = None  # optional custom amounts per execution
+
+
+class PriceTrigger(NadoBaseModel):
+    price_trigger: PriceTriggerData
+
+
+class TimeTrigger(NadoBaseModel):
+    time_trigger: TimeTriggerData
+
+
+TriggerCriteria = Union[PriceTrigger, TimeTrigger]
+
+
 class OrderData(NadoBaseModel):
     sender: str
     priceX18: str