tristero 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

tristero/__init__.py

@@ -1,18 +1,79 @@
-from tristero.client import OrderFailedException, StuckException, SwapException, TokenSpec, execute_permit2_swap, start_permit2_swap, start_feather_swap, wait_for_feather_completion, wait_for_completion, wait_for_completion_with_retry
-from tristero.config import set_config
+from tristero.client import (
+    OrderFailedException,
+    StuckException,
+    SwapException,
+    MarginException,
+    FeatherException,
+    TokenSpec,
+    OrderType,
+    QuoteResult,
+    OrderResult,
+    MarginPosition,
+    FeatherSwapResult,
+    make_async_w3,
+    execute_permit2_swap,
+    execute_swap,
+    start_permit2_swap,
+    start_feather_swap,
+    wait_for_feather_completion,
+    wait_for_completion,
+    wait_for_completion_with_retry,
+    request_margin_quote,
+    sign_order,
+    submit_order,
+    open_margin_position,
+    close_margin_position,
+    list_margin_positions,
+    get_position,
+)
+from tristero.config import set_config, Config
 from tristero.data import ChainID
+from tristero.permit2 import get_erc20_contract
+from tristero.api import APIException, QuoteException, get_quote, fill_order
 
 __all__ = [
+    # Enums and Types
     "ChainID",
     "TokenSpec",
+    "OrderType",
+    "QuoteResult",
+    "OrderResult",
+    "MarginPosition",
+    "FeatherSwapResult",
+    "Config",
+    # Exceptions
     "StuckException",
     "OrderFailedException",
     "SwapException",
+    "MarginException",
+    "FeatherException",
+    # Swap Functions
     "start_permit2_swap",
     "start_feather_swap",
     "execute_permit2_swap",
+    "execute_swap",
+    "make_async_w3",
+    # Wait Functions
     "wait_for_feather_completion",
     "wait_for_completion",
     "wait_for_completion_with_retry",
+    # Margin Functions (Quote Flow)
+    "request_margin_quote",
+    "sign_order",
+    "submit_order",
+    # Margin Functions (Direct Execution)
+    "open_margin_position",
+    "close_margin_position",
+    # Position Management
+    "list_margin_positions",
+    "get_position",
+    # Config
     "set_config",
+    # ERC20 Helpers
+    "get_erc20_contract",
+    # Low-level HTTP API
+    "APIException",
+    "QuoteException",
+    "get_quote",
+    "fill_order",
 ]

tristero/api.py

@@ -1,15 +1,26 @@
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
+import os
+import ssl
 import httpx
 from websockets.asyncio.client import connect
+from eth_utils import to_checksum_address
 from tristero.config import get_config
 from tristero.data import get_gas_addr
 
+try:
+    import certifi  # type: ignore
+except Exception:  # pragma: no cover
+    certifi = None
+
+
 class APIException(Exception):
     pass
 
+
 class QuoteException(Exception):
     pass
 
+
 def handle_resp(resp: httpx.Response):
     try:
         resp.raise_for_status()
@@ -25,6 +36,7 @@ def handle_resp(resp: httpx.Response):
                 raise e
         raise APIException(data)
 
+
 async def t_get(client: httpx.AsyncClient, url: str):
     resp = await client.get(url, headers=get_config().headers, timeout=20)
     return handle_resp(resp)
@@ -34,10 +46,36 @@ async def t_post(client: httpx.AsyncClient, url: str, body: Optional[dict[str, A
     resp = await client.post(url, headers=get_config().headers, json=body, timeout=20)
     return handle_resp(resp)
 
+
 def or_native(chain_id: str, address: str):
     return get_gas_addr(chain_id) if address == "native" else address
 
-c = httpx.AsyncClient()
+def _env_truthy(name: str) -> bool:
+    v = os.getenv(name, "").strip().lower()
+    return v in {"1", "true", "yes", "y", "on"}
+
+
+def _httpx_verify_setting():
+    if _env_truthy("TRISTERO_INSECURE_SSL"):
+        return False
+    if certifi is not None:
+        return certifi.where()
+    return True
+
+
+def _ws_ssl_context_for_url(url: str):
+    if not url.lower().startswith("wss://"):
+        return None
+    if _env_truthy("TRISTERO_INSECURE_SSL"):
+        return ssl._create_unverified_context()
+    if certifi is not None:
+        return ssl.create_default_context(cafile=certifi.where())
+    return ssl.create_default_context()
+
+
+# Replace the default client with one that uses certifi (fixes CERTIFICATE_VERIFY_FAILED on some macOS setups)
+c = httpx.AsyncClient(timeout=20, verify=_httpx_verify_setting())
+
 
 async def get_quote(
     from_wallet: str,
@@ -48,9 +86,6 @@ async def get_quote(
     to_address: str,
     amount: int,
 ):
-    from_chain_id = from_chain_id
-    to_chain_id = to_chain_id
-
     from_token_address = or_native(from_chain_id, from_address)
     to_token_address = or_native(to_chain_id, to_address)
 
@@ -66,21 +101,24 @@ async def get_quote(
     resp = await c.post(
         get_config().quoter_url,
         json=data,
+        headers=get_config().headers,
     )
-    # print(data, resp)
     try:
         return handle_resp(resp)
     except Exception as e:
         raise QuoteException(e, data) from e
 
+
 async def fill_order(signature: str, domain: dict[str, Any], message: dict[str, Any]):
     data = {"signature": signature, "domain": domain, "message": message}
     resp = await c.post(
         get_config().filler_url,
         json=data,
+        headers=get_config().headers,
     )
     return handle_resp(resp)
 
+
 async def fill_order_feather(src_chain: str, dst_chain: str, dst_address: str, amount: int, client_id: str = ''):
     data = {
         "client_id": client_id,
@@ -92,13 +130,157 @@ async def fill_order_feather(src_chain: str, dst_chain: str, dst_address: str, a
     resp = await c.post(
         get_config().filler_url,
         json=data,
+        headers=get_config().headers,
     )
     return handle_resp(resp)
 
+
 async def poll_updates(order_id: str):
-    ws = await connect(f"{get_config().ws_url}/{order_id}")
+    base = get_config().ws_url.rstrip("/")
+    ws = await connect(
+        f"{base}/{order_id}",
+        ssl=_ws_ssl_context_for_url(base),
+    )
     return ws
 
+
 async def poll_updates_feather(order_id: str):
-    ws = await connect(f"{get_config().ws_url}/feather/{order_id}")
+    base = get_config().ws_url.rstrip("/")
+    ws = await connect(
+        f"{base}/feather/{order_id}",
+        ssl=_ws_ssl_context_for_url(base),
+    )
     return ws
+
+
+async def get_margin_quote(
+    chain_id: str,
+    wallet_address: str,
+    quote_currency: str,
+    base_currency: str,
+    leverage_ratio: int,
+    collateral_amount: str,
+) -> Dict[str, Any]:
+    """
+    Get a quote for opening a margin position.
+    
+    Args:
+        chain_id: Chain ID (e.g., "42161" for Arbitrum)
+        wallet_address: User's wallet address
+        quote_currency: Quote currency token address (e.g., USDC)
+        base_currency: Base currency token address (e.g., WETH)
+        leverage_ratio: Leverage ratio (e.g., 2 for 2x)
+        collateral_amount: Collateral amount in raw units
+    
+    Returns:
+        Quote response with order_data for signing
+    """
+    payload = {
+        "chain_id": chain_id,
+        "wallet_address": wallet_address,
+        "quote_currency": quote_currency,
+        "base_currency": base_currency,
+        "leverage_ratio": leverage_ratio,
+        "collateral_amount": collateral_amount,
+    }
+    resp = await c.post(
+        f"{get_config().margin_quoter_url.rstrip('/')}/margin",
+        json=payload,
+        headers=get_config().headers,
+    )
+    data = handle_resp(resp)
+    if not data.get("success"):
+        raise QuoteException(data.get("message") or "margin quote failed", payload)
+    return data
+
+
+async def submit_margin_order(signed_order_payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Submit a signed margin order.
+    
+    Args:
+        signed_order_payload: Signed order from sign_margin_order
+    
+    Returns:
+        Submission response with order_id
+    """
+    resp = await c.post(
+        f"{get_config().margin_filler_url.rstrip('/')}/",
+        json=signed_order_payload,
+        headers=get_config().headers,
+    )
+    return handle_resp(resp)
+
+
+async def submit_close_position(signed_close_payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Submit a signed close position request.
+    
+    Args:
+        signed_close_payload: Signed close request from sign_close_position
+    
+    Returns:
+        Close response with order_id
+    """
+    resp = await c.post(
+        f"{get_config().margin_filler_url.rstrip('/')}/close-margin-position",
+        json=signed_close_payload,
+        headers=get_config().headers,
+    )
+    return handle_resp(resp)
+
+
+async def get_margin_positions(wallet_address: str) -> List[Dict[str, Any]]:
+    """
+    Get all margin positions for a wallet.
+    
+    Args:
+        wallet_address: User's wallet address
+    
+    Returns:
+        List of margin positions
+    """
+    wallet = to_checksum_address(wallet_address)
+    resp = await c.get(
+        f"{get_config().wallet_server_url}/{wallet}/margin-positions",
+        headers=get_config().headers,
+    )
+    return handle_resp(resp)
+
+
+async def get_margin_position(position_id: str) -> Dict[str, Any]:
+    """
+    Get a specific margin position by ID.
+    
+    Args:
+        position_id: Position ID
+    
+    Returns:
+        Margin position details
+    """
+    resp = await c.get(
+        f"{get_config().wallet_server_url}/margin-positions/{position_id}",
+        headers=get_config().headers,
+    )
+    return handle_resp(resp)
+
+
+async def poll_margin_updates(order_id: str):
+    """
+    Open a WebSocket connection to poll margin order updates.
+    
+    Args:
+        order_id: Margin order ID
+    
+    Returns:
+        WebSocket connection
+    """
+    base = get_config().ws_url.rstrip("/")
+    ssl_ctx = _ws_ssl_context_for_url(base)
+
+    # Some deployments expose margin order updates on the same channel as normal orders.
+    # Try the non-/margin path first (fixes local 403), then fall back to /margin.
+    try:
+        return await connect(f"{base}/{order_id}", ssl=ssl_ctx)
+    except Exception:
+        return await connect(f"{base}/margin/{order_id}", ssl=ssl_ctx)