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

tristero/__init__.py

@@ -1,12 +1,79 @@
-from tristero.client import OrderFailedException, StuckException, SwapException, TokenSpec, execute_swap, start_swap
-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",
-    "start_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,80 +1,26 @@
-from enum import Enum
-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 ChainID(str, Enum):
-    arbitrum = "42161"
-    avalanche = "43114"
-    base = "8453"
-    blast = "81457"
-    bsc = "56"
-    celo = "42220"
-    ethereum = "1"
-    mantle = "5000"
-    mode = "34443"
-    opbnb = "204"
-    optimism = "10"
-    polygon = "137"
-    scroll = "534352"
-    solana = "1151111081099710"
-    tron = "728126428"
-    unichain = "130"
-    sei = "1329"
-    sonic = "146"
-    linea = "59144"
-    worldchain = "480"
-    codex = "81224"
-    plume = "98866"
-    hyperevm = "999"
-
-_WRAPPED_GAS_ADDRESSES = {
-    ChainID.ethereum: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    ChainID.unichain: "0x4200000000000000000000000000000000000006",
-    ChainID.optimism: "0x4200000000000000000000000000000000000006",
-    ChainID.arbitrum: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    ChainID.avalanche: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
-    ChainID.polygon: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    ChainID.base: "0x4200000000000000000000000000000000000006",
-    ChainID.bsc: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
-    ChainID.blast: "0x4300000000000000000000000000000000000004",
-    ChainID.mode: "0x4200000000000000000000000000000000000006",
-    ChainID.solana: "So11111111111111111111111111111111111111112",
-    ChainID.sonic: "0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38",
-    ChainID.linea: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f",
-    ChainID.sei: "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
-    ChainID.worldchain: "0x4200000000000000000000000000000000000006",
-    ChainID.plume: "0xEa237441c92CAe6FC17Caaf9a7acB3f953be4bd1",
-    ChainID.hyperevm: "0x5555555555555555555555555555555555555555",
-}
-
-_PERMIT2_CONTRACT_ADDRESSES = {
-    ChainID.ethereum: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.avalanche: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.arbitrum: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.base: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.bsc: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.optimism: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.polygon: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.unichain: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.linea: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.worldchain: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.sonic: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.sei: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.blast: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.mode: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.scroll: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.plume: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    ChainID.hyperevm: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-}
 
 class APIException(Exception):
     pass
 
+
 class QuoteException(Exception):
     pass
 
+
 def handle_resp(resp: httpx.Response):
     try:
         resp.raise_for_status()
@@ -90,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)
@@ -100,59 +47,240 @@ async def t_post(client: httpx.AsyncClient, url: str, body: Optional[dict[str, A
     return handle_resp(resp)
 
 
-def native_address(chain_id: ChainID) -> str:
-    return "0x0000000000000000000000000000000000000000"
+def or_native(chain_id: str, address: str):
+    return get_gas_addr(chain_id) if address == "native" else address
+
+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 or_native(chain_id: ChainID, address: str):
-    return native_address(chain_id) if address == "native" else address
+
+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,
     to_wallet: str,
-    from_chain_id: ChainID,
+    from_chain_id: str,
     from_address: str,
-    to_chain_id: ChainID,
+    to_chain_id: str,
     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)
 
-    async with httpx.AsyncClient() as c:
-        data = {
-            "src_chain_id": from_chain_id.value,
-            "src_token_address": from_token_address,
-            "src_token_quantity": str(int(amount)),
-            "src_wallet_address": from_wallet,
-            "dst_chain_id": to_chain_id.value,
-            "dst_token_address": to_token_address,
-            "dst_wallet_address": to_wallet,
-        }
-        resp = await c.post(
-            get_config().quoter_url,
-            json=data,
-        )
-        # print(data, resp)
-        try:
-            return handle_resp(resp)
-        except Exception as e:
-            raise QuoteException(e, data) from e
+    data = {
+        "src_chain_id": from_chain_id,
+        "src_token_address": from_token_address,
+        "src_token_quantity": str(int(amount)),
+        "src_wallet_address": from_wallet,
+        "dst_chain_id": to_chain_id,
+        "dst_token_address": to_token_address,
+        "dst_wallet_address": to_wallet,
+    }
+    resp = await c.post(
+        get_config().quoter_url,
+        json=data,
+        headers=get_config().headers,
+    )
+    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]):
-    async with httpx.AsyncClient() as c:
-        data = {"signature": signature, "domain": domain, "message": message}
-        resp = await c.post(
-            get_config().filler_url,
-            json=data,
-        )
-        return handle_resp(resp)
+    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,
+        "src_chain": src_chain,
+        "dst_chain": dst_chain,
+        "dst_address": dst_address,
+        "amount": amount
+    }
+    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):
+    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)