pulse-bybit 0.1.0__tar.gz

pulse_bybit-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: pulse-bybit
+Version: 0.1.0
+Summary: Bybit adapter for PULSE Protocol — trade with PULSE messages
+Author-email: PULSE Protocol Team <pulse@protocol.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-bybit
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-bybit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pulse-protocol>=0.5.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"

pulse_bybit-0.1.0/pulse_bybit/__init__.py

@@ -0,0 +1,22 @@
+"""
+PULSE-Bybit Adapter.
+
+Bridge PULSE Protocol messages to Bybit V5 API.
+Same interface as pulse-binance — swap exchanges in one line.
+
+Example:
+    >>> from pulse_bybit import BybitAdapter
+    >>> adapter = BybitAdapter(api_key="...", api_secret="...")
+    >>> from pulse import PulseMessage
+    >>> msg = PulseMessage(
+    ...     action="ACT.QUERY.DATA",
+    ...     parameters={"symbol": "BTCUSDT"}
+    ... )
+    >>> response = adapter.send(msg)
+    >>> print(response.content["parameters"]["result"]["price"])
+"""
+
+from pulse_bybit.adapter import BybitAdapter
+from pulse_bybit.version import __version__
+
+__all__ = ["BybitAdapter", "__version__"]

pulse_bybit-0.1.0/pulse_bybit/adapter.py

@@ -0,0 +1,389 @@
+"""Bybit V5 adapter for PULSE Protocol.
+
+Translates PULSE semantic messages to Bybit V5 unified API.
+Same interface as BinanceAdapter — swap exchanges in one line.
+
+Example:
+    >>> adapter = BybitAdapter(api_key="...", api_secret="...")
+    >>> msg = PulseMessage(
+    ...     action="ACT.QUERY.DATA",
+    ...     parameters={"symbol": "BTCUSDT"}
+    ... )
+    >>> response = adapter.send(msg)
+"""
+
+import hashlib
+import hmac
+import time
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from pulse.message import PulseMessage
+from pulse.adapter import PulseAdapter, AdapterError, AdapterConnectionError
+
+
+# Bybit V5 API endpoints
+ENDPOINTS = {
+    "tickers": "/v5/market/tickers",
+    "kline": "/v5/market/kline",
+    "orderbook": "/v5/market/orderbook",
+    "server_time": "/v5/market/time",
+    "place_order": "/v5/order/create",
+    "cancel_order": "/v5/order/cancel",
+    "order_detail": "/v5/order/realtime",
+    "open_orders": "/v5/order/realtime",
+    "wallet_balance": "/v5/account/wallet-balance",
+}
+
+# Map PULSE actions to Bybit operations
+ACTION_MAP = {
+    "ACT.QUERY.DATA": "query",
+    "ACT.QUERY.STATUS": "order_status",
+    "ACT.TRANSACT.REQUEST": "place_order",
+    "ACT.CANCEL": "cancel_order",
+    "ACT.QUERY.LIST": "open_orders",
+    "ACT.QUERY.BALANCE": "wallet_balance",
+}
+
+
+class BybitAdapter(PulseAdapter):
+    """PULSE adapter for Bybit exchange (V5 API).
+
+    Translates PULSE semantic actions to Bybit V5 unified API.
+    Same interface as BinanceAdapter — switch exchanges in one line.
+
+    Supported PULSE actions:
+        - ACT.QUERY.DATA — get ticker price, klines, order book
+        - ACT.QUERY.STATUS — check order status
+        - ACT.QUERY.LIST — list open orders
+        - ACT.QUERY.BALANCE — get wallet balance
+        - ACT.TRANSACT.REQUEST — place an order (BUY/SELL)
+        - ACT.CANCEL — cancel an order
+
+    Example:
+        >>> # Switch from Binance to Bybit — one line change
+        >>> # adapter = BinanceAdapter(api_key="...", api_secret="...")
+        >>> adapter = BybitAdapter(api_key="...", api_secret="...")
+        >>> msg = PulseMessage(
+        ...     action="ACT.QUERY.DATA",
+        ...     parameters={"symbol": "BTCUSDT"}
+        ... )
+        >>> response = adapter.send(msg)
+    """
+
+    BASE_URL = "https://api.bybit.com"
+    TESTNET_URL = "https://api-testnet.bybit.com"
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_secret: Optional[str] = None,
+        testnet: bool = False,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        base_url = self.TESTNET_URL if testnet else self.BASE_URL
+        super().__init__(
+            name="bybit",
+            base_url=base_url,
+            config=config or {},
+        )
+        self._api_key = api_key
+        self._api_secret = api_secret
+        self._testnet = testnet
+        self._session: Optional[requests.Session] = None
+        self._recv_window = "5000"
+
+    def connect(self) -> None:
+        """Initialize HTTP session and verify connectivity."""
+        self._session = requests.Session()
+
+        try:
+            resp = self._session.get(f"{self.base_url}{ENDPOINTS['server_time']}", timeout=10)
+            resp.raise_for_status()
+            self.connected = True
+        except requests.ConnectionError as e:
+            raise AdapterConnectionError(f"Cannot reach Bybit API: {e}") from e
+        except requests.HTTPError as e:
+            raise AdapterConnectionError(f"Bybit API error: {e}") from e
+
+    def disconnect(self) -> None:
+        """Close HTTP session."""
+        if self._session:
+            self._session.close()
+        self._session = None
+        self.connected = False
+
+    def to_native(self, message: PulseMessage) -> Dict[str, Any]:
+        """Convert PULSE message to Bybit API request."""
+        action = message.content["action"]
+        params = message.content.get("parameters", {})
+        operation = ACTION_MAP.get(action)
+
+        if not operation:
+            raise AdapterError(
+                f"Unsupported action '{action}'. Supported: {list(ACTION_MAP.keys())}"
+            )
+
+        if operation == "query":
+            return self._build_query_request(params)
+        elif operation == "place_order":
+            return self._build_order_request(params)
+        elif operation == "cancel_order":
+            return self._build_cancel_request(params)
+        elif operation == "order_status":
+            return self._build_status_request(params)
+        elif operation == "open_orders":
+            return self._build_open_orders_request(params)
+        elif operation == "wallet_balance":
+            return self._build_balance_request(params)
+
+        raise AdapterError(f"Unknown operation: {operation}")
+
+    def call_api(self, native_request: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute Bybit API call."""
+        if not self._session:
+            self._ensure_session()
+
+        method = native_request["method"]
+        url = f"{self.base_url}{native_request['endpoint']}"
+        params = native_request.get("params", {})
+        signed = native_request.get("signed", False)
+
+        try:
+            if method == "GET":
+                headers = self._sign_get(params) if signed else {}
+                resp = self._session.get(url, params=params, headers=headers, timeout=10)
+            elif method == "POST":
+                headers = self._sign_post(params) if signed else {"Content-Type": "application/json"}
+                resp = self._session.post(url, json=params, headers=headers, timeout=10)
+            else:
+                raise AdapterError(f"Unknown HTTP method: {method}")
+
+            data = resp.json()
+
+            # Bybit V5 uses retCode for errors
+            ret_code = data.get("retCode", 0)
+            if ret_code != 0:
+                ret_msg = data.get("retMsg", "Unknown error")
+                raise AdapterError(f"Bybit error {ret_code}: {ret_msg}")
+
+            return data.get("result", data)
+
+        except (requests.ConnectionError, ConnectionError) as e:
+            raise AdapterConnectionError(f"Cannot reach Bybit: {e}") from e
+        except (requests.Timeout, TimeoutError) as e:
+            raise AdapterConnectionError(f"Bybit request timed out: {e}") from e
+        except AdapterError:
+            raise
+        except Exception as e:
+            raise AdapterError(f"Bybit request failed: {e}") from e
+
+    def from_native(self, native_response: Any) -> PulseMessage:
+        """Convert Bybit response to PULSE message."""
+        return PulseMessage(
+            action="ACT.RESPOND",
+            parameters={"result": native_response},
+            validate=False,
+        )
+
+    @property
+    def supported_actions(self) -> List[str]:
+        return list(ACTION_MAP.keys())
+
+    # --- Request Builders ---
+
+    def _build_query_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build market data query."""
+        symbol = params.get("symbol")
+        query_type = params.get("type", "price")
+        category = params.get("category", "spot")
+
+        if query_type in ("price", "24h"):
+            req_params = {"category": category}
+            if symbol:
+                req_params["symbol"] = symbol.upper()
+            return {
+                "method": "GET",
+                "endpoint": ENDPOINTS["tickers"],
+                "params": req_params,
+                "signed": False,
+            }
+
+        elif query_type == "klines":
+            if not symbol:
+                raise AdapterError("Symbol required for klines query.")
+            return {
+                "method": "GET",
+                "endpoint": ENDPOINTS["kline"],
+                "params": {
+                    "category": category,
+                    "symbol": symbol.upper(),
+                    "interval": params.get("interval", "60"),
+                    "limit": params.get("limit", 100),
+                },
+                "signed": False,
+            }
+
+        elif query_type == "depth":
+            if not symbol:
+                raise AdapterError("Symbol required for depth query.")
+            return {
+                "method": "GET",
+                "endpoint": ENDPOINTS["orderbook"],
+                "params": {
+                    "category": category,
+                    "symbol": symbol.upper(),
+                    "limit": params.get("limit", 20),
+                },
+                "signed": False,
+            }
+
+        raise AdapterError(f"Unknown query type '{query_type}'. Use: price, 24h, klines, depth.")
+
+    def _build_order_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build order placement request."""
+        required = ["symbol", "side", "quantity"]
+        for field in required:
+            if field not in params:
+                raise AdapterError(f"Missing required field '{field}' for order placement.")
+
+        order_params = {
+            "category": params.get("category", "spot"),
+            "symbol": params["symbol"].upper(),
+            "side": "Buy" if params["side"].upper() == "BUY" else "Sell",
+            "orderType": params.get("order_type", "Market"),
+            "qty": str(params["quantity"]),
+        }
+
+        if order_params["orderType"].upper() == "LIMIT":
+            if "price" not in params:
+                raise AdapterError("Price required for LIMIT orders.")
+            order_params["orderType"] = "Limit"
+            order_params["price"] = str(params["price"])
+            order_params["timeInForce"] = params.get("time_in_force", "GTC")
+
+        return {
+            "method": "POST",
+            "endpoint": ENDPOINTS["place_order"],
+            "params": order_params,
+            "signed": True,
+        }
+
+    def _build_cancel_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build order cancellation request."""
+        if "symbol" not in params:
+            raise AdapterError("Symbol required for order cancellation.")
+        if "order_id" not in params:
+            raise AdapterError("Order ID required for cancellation.")
+
+        return {
+            "method": "POST",
+            "endpoint": ENDPOINTS["cancel_order"],
+            "params": {
+                "category": params.get("category", "spot"),
+                "symbol": params["symbol"].upper(),
+                "orderId": str(params["order_id"]),
+            },
+            "signed": True,
+        }
+
+    def _build_status_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build order status query."""
+        if "symbol" not in params:
+            raise AdapterError("Symbol required for order status query.")
+        if "order_id" not in params:
+            raise AdapterError("Order ID required for status query.")
+
+        return {
+            "method": "GET",
+            "endpoint": ENDPOINTS["order_detail"],
+            "params": {
+                "category": params.get("category", "spot"),
+                "symbol": params["symbol"].upper(),
+                "orderId": str(params["order_id"]),
+            },
+            "signed": True,
+        }
+
+    def _build_open_orders_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build open orders query."""
+        req_params = {"category": params.get("category", "spot")}
+        if "symbol" in params:
+            req_params["symbol"] = params["symbol"].upper()
+
+        return {
+            "method": "GET",
+            "endpoint": ENDPOINTS["open_orders"],
+            "params": req_params,
+            "signed": True,
+        }
+
+    def _build_balance_request(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Build wallet balance query."""
+        return {
+            "method": "GET",
+            "endpoint": ENDPOINTS["wallet_balance"],
+            "params": {
+                "accountType": params.get("account_type", "UNIFIED"),
+            },
+            "signed": True,
+        }
+
+    # --- Signing ---
+
+    def _sign_get(self, params: Dict[str, Any]) -> Dict[str, str]:
+        """Generate authentication headers for GET requests."""
+        if not self._api_key or not self._api_secret:
+            raise AdapterError("API key and secret required for signed requests.")
+
+        timestamp = str(int(time.time() * 1000))
+        param_str = "&".join(f"{k}={v}" for k, v in sorted(params.items()))
+        sign_str = f"{timestamp}{self._api_key}{self._recv_window}{param_str}"
+
+        signature = hmac.new(
+            self._api_secret.encode("utf-8"),
+            sign_str.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+
+        return {
+            "X-BAPI-API-KEY": self._api_key,
+            "X-BAPI-SIGN": signature,
+            "X-BAPI-TIMESTAMP": timestamp,
+            "X-BAPI-RECV-WINDOW": self._recv_window,
+        }
+
+    def _sign_post(self, params: Dict[str, Any]) -> Dict[str, str]:
+        """Generate authentication headers for POST requests."""
+        if not self._api_key or not self._api_secret:
+            raise AdapterError("API key and secret required for signed requests.")
+
+        import json
+        timestamp = str(int(time.time() * 1000))
+        param_str = json.dumps(params)
+        sign_str = f"{timestamp}{self._api_key}{self._recv_window}{param_str}"
+
+        signature = hmac.new(
+            self._api_secret.encode("utf-8"),
+            sign_str.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+
+        return {
+            "X-BAPI-API-KEY": self._api_key,
+            "X-BAPI-SIGN": signature,
+            "X-BAPI-TIMESTAMP": timestamp,
+            "X-BAPI-RECV-WINDOW": self._recv_window,
+            "Content-Type": "application/json",
+        }
+
+    def _ensure_session(self) -> None:
+        if not self._session:
+            self._session = requests.Session()
+
+    def __repr__(self) -> str:
+        return (
+            f"BybitAdapter(testnet={self._testnet}, "
+            f"connected={self.connected})"
+        )

pulse_bybit-0.1.0/pulse_bybit/version.py

@@ -0,0 +1,4 @@
+"""Version information for pulse-bybit."""
+
+__version__ = "0.1.0"
+__version_info__ = (0, 1, 0)

pulse_bybit-0.1.0/pulse_bybit.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: pulse-bybit
+Version: 0.1.0
+Summary: Bybit adapter for PULSE Protocol — trade with PULSE messages
+Author-email: PULSE Protocol Team <pulse@protocol.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-bybit
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-bybit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pulse-protocol>=0.5.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"

pulse_bybit-0.1.0/pulse_bybit.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+pulse_bybit/__init__.py
+pulse_bybit/adapter.py
+pulse_bybit/version.py
+pulse_bybit.egg-info/PKG-INFO
+pulse_bybit.egg-info/SOURCES.txt
+pulse_bybit.egg-info/dependency_links.txt
+pulse_bybit.egg-info/requires.txt
+pulse_bybit.egg-info/top_level.txt
+tests/test_bybit_adapter.py

pulse_bybit-0.1.0/pulse_bybit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pulse_bybit-0.1.0/pulse_bybit.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pulse-protocol>=0.5.0
+requests>=2.28.0
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0

pulse_bybit-0.1.0/pulse_bybit.egg-info/top_level.txt

@@ -0,0 +1 @@
+pulse_bybit

pulse_bybit-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pulse-bybit"
+version = "0.1.0"
+description = "Bybit adapter for PULSE Protocol — trade with PULSE messages"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.8"
+authors = [
+    {name = "PULSE Protocol Team", email = "pulse@protocol.org"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = [
+    "pulse-protocol>=0.5.0",
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/pulseprotocolorg-cyber/pulse-bybit"
+Repository = "https://github.com/pulseprotocolorg-cyber/pulse-bybit"
+
+[tool.setuptools.packages.find]
+include = ["pulse_bybit*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 100

pulse_bybit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pulse_bybit-0.1.0/tests/test_bybit_adapter.py

@@ -0,0 +1,401 @@
+"""Tests for Bybit adapter. All mocked — no real API calls."""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from pulse.message import PulseMessage
+from pulse.adapter import AdapterError, AdapterConnectionError
+
+from pulse_bybit import BybitAdapter
+
+
+# --- Mock Helpers ---
+
+
+def mock_response(result_data, ret_code=0, ret_msg="OK"):
+    """Create a mock Bybit V5 response."""
+    mock = MagicMock()
+    mock.status_code = 200
+    mock.json.return_value = {
+        "retCode": ret_code,
+        "retMsg": ret_msg,
+        "result": result_data,
+    }
+    mock.raise_for_status.return_value = None
+    return mock
+
+
+# --- Fixtures ---
+
+
+@pytest.fixture
+def adapter():
+    a = BybitAdapter(api_key="test-key", api_secret="test-secret")
+    a._session = MagicMock()
+    a.connected = True
+    return a
+
+
+@pytest.fixture
+def price_message():
+    return PulseMessage(
+        action="ACT.QUERY.DATA",
+        parameters={"symbol": "BTCUSDT"},
+        sender="test-bot",
+    )
+
+
+@pytest.fixture
+def klines_message():
+    return PulseMessage(
+        action="ACT.QUERY.DATA",
+        parameters={"symbol": "BTCUSDT", "type": "klines", "interval": "60"},
+        sender="test-bot",
+    )
+
+
+@pytest.fixture
+def buy_message():
+    return PulseMessage(
+        action="ACT.TRANSACT.REQUEST",
+        parameters={"symbol": "BTCUSDT", "side": "BUY", "quantity": 0.001},
+        sender="test-bot",
+        validate=False,
+    )
+
+
+@pytest.fixture
+def cancel_message():
+    return PulseMessage(
+        action="ACT.CANCEL",
+        parameters={"symbol": "BTCUSDT", "order_id": "abc123"},
+        sender="test-bot",
+        validate=False,
+    )
+
+
+@pytest.fixture
+def status_message():
+    return PulseMessage(
+        action="ACT.QUERY.STATUS",
+        parameters={"symbol": "BTCUSDT", "order_id": "abc123"},
+        sender="test-bot",
+        validate=False,
+    )
+
+
+@pytest.fixture
+def balance_message():
+    return PulseMessage(
+        action="ACT.QUERY.BALANCE",
+        parameters={},
+        sender="test-bot",
+        validate=False,
+    )
+
+
+# --- Test Initialization ---
+
+
+class TestBybitAdapterInit:
+
+    def test_basic_init(self):
+        adapter = BybitAdapter(api_key="key", api_secret="secret")
+        assert adapter.name == "bybit"
+        assert adapter.base_url == "https://api.bybit.com"
+        assert adapter.connected is False
+
+    def test_testnet_init(self):
+        adapter = BybitAdapter(testnet=True)
+        assert adapter.base_url == "https://api-testnet.bybit.com"
+
+    def test_repr(self):
+        adapter = BybitAdapter()
+        assert "testnet=False" in repr(adapter)
+
+
+# --- Test to_native: Market Data ---
+
+
+class TestToNativeMarketData:
+
+    def test_price_query(self, adapter, price_message):
+        native = adapter.to_native(price_message)
+        assert native["method"] == "GET"
+        assert native["endpoint"] == "/v5/market/tickers"
+        assert native["params"]["symbol"] == "BTCUSDT"
+        assert native["params"]["category"] == "spot"
+        assert native["signed"] is False
+
+    def test_klines_query(self, adapter, klines_message):
+        native = adapter.to_native(klines_message)
+        assert native["endpoint"] == "/v5/market/kline"
+        assert native["params"]["interval"] == "60"
+
+    def test_depth_query(self, adapter):
+        msg = PulseMessage(
+            action="ACT.QUERY.DATA",
+            parameters={"symbol": "BTCUSDT", "type": "depth"},
+        )
+        native = adapter.to_native(msg)
+        assert native["endpoint"] == "/v5/market/orderbook"
+
+    def test_symbol_uppercased(self, adapter):
+        msg = PulseMessage(action="ACT.QUERY.DATA", parameters={"symbol": "btcusdt"})
+        native = adapter.to_native(msg)
+        assert native["params"]["symbol"] == "BTCUSDT"
+
+    def test_unknown_query_type_raises(self, adapter):
+        msg = PulseMessage(action="ACT.QUERY.DATA", parameters={"type": "invalid"})
+        with pytest.raises(AdapterError, match="Unknown query type"):
+            adapter.to_native(msg)
+
+    def test_klines_no_symbol_raises(self, adapter):
+        msg = PulseMessage(action="ACT.QUERY.DATA", parameters={"type": "klines"})
+        with pytest.raises(AdapterError, match="Symbol required"):
+            adapter.to_native(msg)
+
+    def test_custom_category(self, adapter):
+        msg = PulseMessage(
+            action="ACT.QUERY.DATA",
+            parameters={"symbol": "BTCUSDT", "category": "linear"},
+        )
+        native = adapter.to_native(msg)
+        assert native["params"]["category"] == "linear"
+
+
+# --- Test to_native: Orders ---
+
+
+class TestToNativeOrders:
+
+    def test_market_buy(self, adapter, buy_message):
+        native = adapter.to_native(buy_message)
+        assert native["method"] == "POST"
+        assert native["endpoint"] == "/v5/order/create"
+        assert native["params"]["symbol"] == "BTCUSDT"
+        assert native["params"]["side"] == "Buy"
+        assert native["params"]["orderType"] == "Market"
+        assert native["params"]["qty"] == "0.001"
+        assert native["signed"] is True
+
+    def test_sell_side(self, adapter):
+        msg = PulseMessage(
+            action="ACT.TRANSACT.REQUEST",
+            parameters={"symbol": "BTCUSDT", "side": "SELL", "quantity": 0.1},
+            validate=False,
+        )
+        native = adapter.to_native(msg)
+        assert native["params"]["side"] == "Sell"
+
+    def test_limit_order(self, adapter):
+        msg = PulseMessage(
+            action="ACT.TRANSACT.REQUEST",
+            validate=False,
+            parameters={
+                "symbol": "ETHUSDT", "side": "BUY", "quantity": 1,
+                "order_type": "LIMIT", "price": 2000,
+            },
+        )
+        native = adapter.to_native(msg)
+        assert native["params"]["orderType"] == "Limit"
+        assert native["params"]["price"] == "2000"
+        assert native["params"]["timeInForce"] == "GTC"
+
+    def test_limit_no_price_raises(self, adapter):
+        msg = PulseMessage(
+            action="ACT.TRANSACT.REQUEST",
+            parameters={"symbol": "BTCUSDT", "side": "BUY", "quantity": 1, "order_type": "LIMIT"},
+            validate=False,
+        )
+        with pytest.raises(AdapterError, match="Price required"):
+            adapter.to_native(msg)
+
+    def test_order_missing_field_raises(self, adapter):
+        msg = PulseMessage(
+            action="ACT.TRANSACT.REQUEST",
+            parameters={"symbol": "BTCUSDT", "side": "BUY"},
+            validate=False,
+        )
+        with pytest.raises(AdapterError, match="Missing required field"):
+            adapter.to_native(msg)
+
+    def test_cancel_order(self, adapter, cancel_message):
+        native = adapter.to_native(cancel_message)
+        assert native["method"] == "POST"
+        assert native["endpoint"] == "/v5/order/cancel"
+        assert native["params"]["orderId"] == "abc123"
+        assert native["signed"] is True
+
+    def test_cancel_no_symbol_raises(self, adapter):
+        msg = PulseMessage(action="ACT.CANCEL", parameters={"order_id": "123"}, validate=False)
+        with pytest.raises(AdapterError, match="Symbol required"):
+            adapter.to_native(msg)
+
+
+# --- Test to_native: Account ---
+
+
+class TestToNativeAccount:
+
+    def test_order_status(self, adapter, status_message):
+        native = adapter.to_native(status_message)
+        assert native["endpoint"] == "/v5/order/realtime"
+        assert native["params"]["orderId"] == "abc123"
+        assert native["signed"] is True
+
+    def test_open_orders(self, adapter):
+        msg = PulseMessage(action="ACT.QUERY.LIST", parameters={}, validate=False)
+        native = adapter.to_native(msg)
+        assert native["endpoint"] == "/v5/order/realtime"
+        assert native["signed"] is True
+
+    def test_wallet_balance(self, adapter, balance_message):
+        native = adapter.to_native(balance_message)
+        assert native["endpoint"] == "/v5/account/wallet-balance"
+        assert native["signed"] is True
+
+    def test_unsupported_action_raises(self, adapter):
+        msg = PulseMessage(action="ACT.CREATE.TEXT", parameters={}, validate=False)
+        with pytest.raises(AdapterError, match="Unsupported action"):
+            adapter.to_native(msg)
+
+
+# --- Test call_api ---
+
+
+class TestCallAPI:
+
+    def test_get_request(self, adapter):
+        adapter._session.get.return_value = mock_response(
+            {"list": [{"symbol": "BTCUSDT", "lastPrice": "65000"}]}
+        )
+        result = adapter.call_api({
+            "method": "GET",
+            "endpoint": "/v5/market/tickers",
+            "params": {"category": "spot", "symbol": "BTCUSDT"},
+            "signed": False,
+        })
+        assert result["list"][0]["lastPrice"] == "65000"
+
+    def test_post_request(self, adapter):
+        adapter._session.post.return_value = mock_response(
+            {"orderId": "abc123", "orderLinkId": ""}
+        )
+        result = adapter.call_api({
+            "method": "POST",
+            "endpoint": "/v5/order/create",
+            "params": {"symbol": "BTCUSDT", "side": "Buy", "qty": "0.001"},
+            "signed": True,
+        })
+        assert result["orderId"] == "abc123"
+
+    def test_api_error_response(self, adapter):
+        adapter._session.get.return_value = mock_response(
+            {}, ret_code=10001, ret_msg="Invalid symbol"
+        )
+        with pytest.raises(AdapterError, match="Invalid symbol"):
+            adapter.call_api({
+                "method": "GET",
+                "endpoint": "/v5/market/tickers",
+                "params": {"symbol": "INVALID"},
+                "signed": False,
+            })
+
+    def test_connection_error(self, adapter):
+        adapter._session.get.side_effect = ConnectionError("Network down")
+        with pytest.raises(AdapterConnectionError, match="Cannot reach"):
+            adapter.call_api({
+                "method": "GET",
+                "endpoint": "/v5/market/tickers",
+                "signed": False,
+            })
+
+
+# --- Test Full Pipeline ---
+
+
+class TestFullPipeline:
+
+    def test_price_query(self, adapter, price_message):
+        adapter._session.get.return_value = mock_response(
+            {"list": [{"symbol": "BTCUSDT", "lastPrice": "65000.50"}]}
+        )
+        response = adapter.send(price_message)
+        assert response.type == "RESPONSE"
+        assert response.envelope["sender"] == "adapter:bybit"
+        assert response.content["parameters"]["result"]["list"][0]["lastPrice"] == "65000.50"
+
+    def test_order_pipeline(self, adapter, buy_message):
+        adapter._session.post.return_value = mock_response(
+            {"orderId": "order-123", "orderLinkId": ""}
+        )
+        response = adapter.send(buy_message)
+        assert response.content["parameters"]["result"]["orderId"] == "order-123"
+
+    def test_pipeline_tracks_requests(self, adapter, price_message):
+        adapter._session.get.return_value = mock_response({"list": []})
+        adapter.send(price_message)
+        adapter.send(price_message)
+        assert adapter._request_count == 2
+
+
+# --- Test Signing ---
+
+
+class TestSigning:
+
+    def test_sign_get_headers(self, adapter):
+        params = {"category": "spot", "symbol": "BTCUSDT"}
+        headers = adapter._sign_get(params)
+        assert "X-BAPI-API-KEY" in headers
+        assert "X-BAPI-SIGN" in headers
+        assert "X-BAPI-TIMESTAMP" in headers
+        assert headers["X-BAPI-API-KEY"] == "test-key"
+        assert len(headers["X-BAPI-SIGN"]) == 64
+
+    def test_sign_post_headers(self, adapter):
+        params = {"symbol": "BTCUSDT", "side": "Buy"}
+        headers = adapter._sign_post(params)
+        assert "X-BAPI-SIGN" in headers
+        assert "Content-Type" in headers
+
+    def test_sign_without_key_raises(self, adapter):
+        adapter._api_key = None
+        with pytest.raises(AdapterError, match="API key and secret required"):
+            adapter._sign_get({"test": "param"})
+
+
+# --- Test Supported Actions ---
+
+
+class TestSupportedActions:
+
+    def test_supported_actions(self, adapter):
+        actions = adapter.supported_actions
+        assert "ACT.QUERY.DATA" in actions
+        assert "ACT.TRANSACT.REQUEST" in actions
+        assert "ACT.CANCEL" in actions
+        assert len(actions) == 6
+
+    def test_supports_check(self, adapter):
+        assert adapter.supports("ACT.QUERY.DATA") is True
+        assert adapter.supports("ACT.CREATE.TEXT") is False
+
+
+# --- Test Exchange Switching ---
+
+
+class TestExchangeSwitching:
+    """Prove exchange switching works."""
+
+    def test_same_actions_as_binance(self):
+        from pulse_binance import BinanceAdapter
+        binance = BinanceAdapter(api_key="k", api_secret="s")
+        bybit = BybitAdapter(api_key="k", api_secret="s")
+        assert set(binance.supported_actions) == set(bybit.supported_actions)
+
+    def test_same_message_works(self, adapter, price_message):
+        adapter._session.get.return_value = mock_response({"list": []})
+        response = adapter.send(price_message)
+        assert response.type == "RESPONSE"