irl-gateway 0.2.0__tar.gz

irl_gateway-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MacroPulse Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

irl_gateway-0.2.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: irl-gateway
+Version: 0.2.0
+Summary: MCP trading gateway for AI agents: IRL pre-trade policy, sealed rationale, and verifiable fills.
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<3,>=2.3
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: ccxt>=4.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: isort>=5.13; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.9; extra == "dev"
+Dynamic: license-file
+
+# IRL Gateway
+
+<!-- mcp-name: io.github.macropulse-lab/irl-gateway -->
+
+**Give your AI agent a trading account it can't misuse, and a record of every decision it can't rewrite.**
+
+IRL Gateway is an [MCP](https://modelcontextprotocol.io) server that sits between an AI agent (Claude, ChatGPT, or your own) and an exchange account. Every order the agent places goes through the [IRL Engine](https://irl.macropulse.live):
+
+1. **Policy before execution.** IRL checks the order against the agent's mandate (active status, notional cap, allowed assets and venues) before anything reaches the exchange. Out of mandate means no order.
+2. **The rationale is sealed.** The agent must say why it is trading. The gateway hashes that rationale together with the trade inputs and seals the hash into IRL's tamper-evident trace, anchored daily to Bitcoin. The plaintext stays in your local journal.
+3. **Intent is reconciled with the fill.** After the exchange fills the order, IRL compares what was authorized with what executed and records `MATCHED` or `DIVERGENT`.
+
+When something goes wrong, you can prove what the agent was allowed to do, what it said it was doing, and what actually happened.
+
+```
+AI agent ── MCP ──> irl-gateway ──> IRL: authorize (policy + sealed rationale)
+                         │
+                         ├──────> exchange: market order (client id = sealed intent)
+                         │
+                         └──────> IRL: bind fill -> MATCHED / DIVERGENT
+```
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `execute_trade(symbol, side, rationale, quantity \| notional)` | The only tool that moves money. Spot market order through authorize → place → bind. Returns `filled`, `denied`, `blocked` or `failed`, with the IRL `trace_id` and verdict. |
+| `get_policy()` | The agent's mandate as IRL enforces it, plus the local kill-switch state. |
+| `get_quote(symbol)` | Last price on the gateway's venue. |
+| `get_balances()` | Free balances (paper or exchange). |
+| `get_trace(trace_id)` | IRL's sealed record of one trade. |
+| `list_recent_trades(limit)` | Local journal: rationale, context hash, trace id and outcome per trade. |
+
+Behaviour the agent can rely on:
+
+- **Fail closed.** If IRL is unreachable or denies the intent, no order is sent.
+- **Kill switch.** Create the file `~/.irl-gateway/KILL` and every trade is refused before IRL is even called. Delete it to resume.
+- **No silent fills.** If the exchange fills but the IRL bind fails, the result still reports the fill and flags it for reconciliation.
+
+## Quick start (paper trading)
+
+You need an IRL server and an agent registered on it. Paper trading is the default: fills are simulated at live public Binance prices, and no exchange keys are needed.
+
+```bash
+pip install irl-gateway      # or run it without installing: uvx irl-gateway
+```
+
+Register the agent once, with its mandate:
+
+```bash
+curl -X POST "$IRL_BASE_URL/irl/agents" -H "Authorization: Bearer $IRL_API_TOKEN" \
+  -H "Content-Type: application/json" -d '{
+    "name": "my-claude-trader",
+    "model_hash_hex": "<sha256 of your agent config>",
+    "max_notional": 100,
+    "allowed_assets": ["BTC/USDT", "ETH/USDT"],
+    "allowed_venues": ["paper-binance"]
+  }'
+```
+
+Then add the gateway to your MCP client, for example Claude Code or Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "irl-gateway": {
+      "command": "uvx",
+      "args": ["irl-gateway"],
+      "env": {
+        "IRL_BASE_URL": "https://irl.example.com",
+        "IRL_API_TOKEN": "…",
+        "IRL_AGENT_ID": "<agent_id from registration>",
+        "IRL_MODEL_HASH": "<the same model_hash_hex>",
+        "AGENT_MODEL_ID": "claude-opus-5-5",
+        "PAPER_BALANCES": "USDT=1000"
+      }
+    }
+  }
+}
+```
+
+Ask the agent to check `get_policy`, then trade.
+
+## Configuration
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `IRL_BASE_URL`, `IRL_API_TOKEN` | required | IRL server and bearer token |
+| `IRL_AGENT_ID`, `IRL_MODEL_HASH` | required | The registered agent and its model hash |
+| `AGENT_MODEL_ID` | `unspecified-model` | Model name sealed into each trace (the agent can override it per trade) |
+| `AGENT_CONFIG_CHECKSUM` | `none` | Optional checksum of the agent's configuration, sealed into each trace |
+| `IRL_L2_MODE` | `off` | `regime` if your IRL server requires Layer 2 regime binding |
+| `GATEWAY_BROKER` | `paper` | `paper` or `exchange` |
+| `EXCHANGE_ID` | `binance` | Any ccxt exchange id; also the price source for paper trading |
+| `EXCHANGE_API_KEY`, `EXCHANGE_API_SECRET` | | Required for `exchange` |
+| `EXCHANGE_TESTNET` | `true` | Use the exchange's testnet |
+| `PAPER_BALANCES` | `USDT=1000` | Starting paper balances (used only until `paper_state.json` exists; the paper account then persists across restarts) |
+| `IRL_GATEWAY_HOME` | `~/.irl-gateway` | Journal (`journal.jsonl`), kill switch (`KILL`) and paper account (`paper_state.json`) location |
+
+The venue IRL sees is the exchange id (`binance`), or `paper-<exchange>` for paper trading, so a mandate can allow paper trading while denying the real account.
+
+## How the rationale is sealed
+
+For each trade the gateway builds a context of the rationale, symbol, side, quantity, reference price, venue, model id and client order id. It hashes that context as canonical JSON (sorted keys, no whitespace) with SHA-256 and sends the hash to IRL as `prompt_version = "ctx-sha256:<hex>"`, which IRL seals into the trace's `reasoning_hash`.
+
+The journal stores the full context next to its hash, so anyone holding a journal line can recompute the hash and match it to the sealed trace. IRL itself never sees the rationale's text.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+pytest --cov=irl_gateway
+ruff check src tests && black --check src tests && isort --check-only src tests && mypy src
+```
+
+## Status
+
+Early (0.1). Spot market orders only. Paper trading and ccxt exchanges are supported; Alpaca is next. Not investment advice, and no strategy is included: the gateway controls and records what your agent does, it does not decide.
+
+MIT licensed.

irl_gateway-0.2.0/README.md

@@ -0,0 +1,120 @@
+# IRL Gateway
+
+<!-- mcp-name: io.github.macropulse-lab/irl-gateway -->
+
+**Give your AI agent a trading account it can't misuse, and a record of every decision it can't rewrite.**
+
+IRL Gateway is an [MCP](https://modelcontextprotocol.io) server that sits between an AI agent (Claude, ChatGPT, or your own) and an exchange account. Every order the agent places goes through the [IRL Engine](https://irl.macropulse.live):
+
+1. **Policy before execution.** IRL checks the order against the agent's mandate (active status, notional cap, allowed assets and venues) before anything reaches the exchange. Out of mandate means no order.
+2. **The rationale is sealed.** The agent must say why it is trading. The gateway hashes that rationale together with the trade inputs and seals the hash into IRL's tamper-evident trace, anchored daily to Bitcoin. The plaintext stays in your local journal.
+3. **Intent is reconciled with the fill.** After the exchange fills the order, IRL compares what was authorized with what executed and records `MATCHED` or `DIVERGENT`.
+
+When something goes wrong, you can prove what the agent was allowed to do, what it said it was doing, and what actually happened.
+
+```
+AI agent ── MCP ──> irl-gateway ──> IRL: authorize (policy + sealed rationale)
+                         │
+                         ├──────> exchange: market order (client id = sealed intent)
+                         │
+                         └──────> IRL: bind fill -> MATCHED / DIVERGENT
+```
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `execute_trade(symbol, side, rationale, quantity \| notional)` | The only tool that moves money. Spot market order through authorize → place → bind. Returns `filled`, `denied`, `blocked` or `failed`, with the IRL `trace_id` and verdict. |
+| `get_policy()` | The agent's mandate as IRL enforces it, plus the local kill-switch state. |
+| `get_quote(symbol)` | Last price on the gateway's venue. |
+| `get_balances()` | Free balances (paper or exchange). |
+| `get_trace(trace_id)` | IRL's sealed record of one trade. |
+| `list_recent_trades(limit)` | Local journal: rationale, context hash, trace id and outcome per trade. |
+
+Behaviour the agent can rely on:
+
+- **Fail closed.** If IRL is unreachable or denies the intent, no order is sent.
+- **Kill switch.** Create the file `~/.irl-gateway/KILL` and every trade is refused before IRL is even called. Delete it to resume.
+- **No silent fills.** If the exchange fills but the IRL bind fails, the result still reports the fill and flags it for reconciliation.
+
+## Quick start (paper trading)
+
+You need an IRL server and an agent registered on it. Paper trading is the default: fills are simulated at live public Binance prices, and no exchange keys are needed.
+
+```bash
+pip install irl-gateway      # or run it without installing: uvx irl-gateway
+```
+
+Register the agent once, with its mandate:
+
+```bash
+curl -X POST "$IRL_BASE_URL/irl/agents" -H "Authorization: Bearer $IRL_API_TOKEN" \
+  -H "Content-Type: application/json" -d '{
+    "name": "my-claude-trader",
+    "model_hash_hex": "<sha256 of your agent config>",
+    "max_notional": 100,
+    "allowed_assets": ["BTC/USDT", "ETH/USDT"],
+    "allowed_venues": ["paper-binance"]
+  }'
+```
+
+Then add the gateway to your MCP client, for example Claude Code or Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "irl-gateway": {
+      "command": "uvx",
+      "args": ["irl-gateway"],
+      "env": {
+        "IRL_BASE_URL": "https://irl.example.com",
+        "IRL_API_TOKEN": "…",
+        "IRL_AGENT_ID": "<agent_id from registration>",
+        "IRL_MODEL_HASH": "<the same model_hash_hex>",
+        "AGENT_MODEL_ID": "claude-opus-5-5",
+        "PAPER_BALANCES": "USDT=1000"
+      }
+    }
+  }
+}
+```
+
+Ask the agent to check `get_policy`, then trade.
+
+## Configuration
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `IRL_BASE_URL`, `IRL_API_TOKEN` | required | IRL server and bearer token |
+| `IRL_AGENT_ID`, `IRL_MODEL_HASH` | required | The registered agent and its model hash |
+| `AGENT_MODEL_ID` | `unspecified-model` | Model name sealed into each trace (the agent can override it per trade) |
+| `AGENT_CONFIG_CHECKSUM` | `none` | Optional checksum of the agent's configuration, sealed into each trace |
+| `IRL_L2_MODE` | `off` | `regime` if your IRL server requires Layer 2 regime binding |
+| `GATEWAY_BROKER` | `paper` | `paper` or `exchange` |
+| `EXCHANGE_ID` | `binance` | Any ccxt exchange id; also the price source for paper trading |
+| `EXCHANGE_API_KEY`, `EXCHANGE_API_SECRET` | | Required for `exchange` |
+| `EXCHANGE_TESTNET` | `true` | Use the exchange's testnet |
+| `PAPER_BALANCES` | `USDT=1000` | Starting paper balances (used only until `paper_state.json` exists; the paper account then persists across restarts) |
+| `IRL_GATEWAY_HOME` | `~/.irl-gateway` | Journal (`journal.jsonl`), kill switch (`KILL`) and paper account (`paper_state.json`) location |
+
+The venue IRL sees is the exchange id (`binance`), or `paper-<exchange>` for paper trading, so a mandate can allow paper trading while denying the real account.
+
+## How the rationale is sealed
+
+For each trade the gateway builds a context of the rationale, symbol, side, quantity, reference price, venue, model id and client order id. It hashes that context as canonical JSON (sorted keys, no whitespace) with SHA-256 and sends the hash to IRL as `prompt_version = "ctx-sha256:<hex>"`, which IRL seals into the trace's `reasoning_hash`.
+
+The journal stores the full context next to its hash, so anyone holding a journal line can recompute the hash and match it to the sealed trace. IRL itself never sees the rationale's text.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+pytest --cov=irl_gateway
+ruff check src tests && black --check src tests && isort --check-only src tests && mypy src
+```
+
+## Status
+
+Early (0.1). Spot market orders only. Paper trading and ccxt exchanges are supported; Alpaca is next. Not investment advice, and no strategy is included: the gateway controls and records what your agent does, it does not decide.
+
+MIT licensed.

irl_gateway-0.2.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "irl-gateway"
+version = "0.2.0"
+description = "MCP trading gateway for AI agents: IRL pre-trade policy, sealed rationale, and verifiable fills."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+dependencies = [
+    "mcp>=2.3,<3",
+    "aiohttp>=3.9",
+    "ccxt>=4.3",
+]
+
+[project.scripts]
+irl-gateway = "irl_gateway.server:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pytest-cov>=5.0",
+    "black>=24.0",
+    "isort>=5.13",
+    "ruff>=0.4",
+    "mypy>=1.9",
+]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.black]
+target-version = ["py312"]
+line-length = 100
+
+[tool.isort]
+profile = "black"
+line_length = 100
+
+[tool.ruff]
+line-length = 100
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+strict = true

irl_gateway-0.2.0/setup.cfg

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

irl_gateway-0.2.0/src/irl_gateway/__init__.py

@@ -0,0 +1,4 @@
+"""IRL gateway: an MCP server that puts IRL's pre-trade policy and sealed
+audit trail between an AI agent and its exchange account."""
+
+__version__ = "0.2.0"

irl_gateway-0.2.0/src/irl_gateway/__main__.py

@@ -0,0 +1,3 @@
+from irl_gateway.server import main
+
+main()

irl_gateway-0.2.0/src/irl_gateway/brokers.py

@@ -0,0 +1,226 @@
+"""Venues the gateway can execute on, behind one small async interface.
+
+Symbols use ccxt's unified 'BASE/QUOTE' form (e.g. 'BTC/USDT'). Only spot
+market orders are supported: the gateway's job is controlled, audited
+execution, not order-type coverage.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import ccxt.async_support as ccxt_async
+
+
+class Side(str, Enum):
+    BUY = "buy"
+    SELL = "sell"
+
+
+@dataclass(frozen=True)
+class Fill:
+    order_id: str
+    symbol: str
+    side: Side
+    quantity: float
+    price: float
+    fee: float
+    fee_asset: str | None
+
+
+class Broker(ABC):
+    venue_id: str
+
+    @abstractmethod
+    async def get_price(self, symbol: str) -> float: ...
+
+    @abstractmethod
+    async def get_balances(self) -> dict[str, float]:
+        """Free balance per asset, non-zero only."""
+
+    @abstractmethod
+    async def place_market_order(
+        self, symbol: str, side: Side, quantity: float, *, client_order_id: str
+    ) -> Fill: ...
+
+    @abstractmethod
+    async def close(self) -> None: ...
+
+
+def split_symbol(symbol: str) -> tuple[str, str]:
+    base, sep, quote = symbol.partition("/")
+    if not sep or not base or not quote:
+        raise ValueError(f"symbol must look like 'BASE/QUOTE', got {symbol!r}")
+    return base.upper(), quote.upper()
+
+
+class CcxtBroker(Broker):
+    """A real exchange account (or its testnet) through ccxt."""
+
+    def __init__(self, exchange: Any):
+        self._exchange = exchange
+        self.venue_id = str(exchange.id)
+
+    @classmethod
+    def create(
+        cls, exchange_id: str, api_key: str, api_secret: str, *, testnet: bool
+    ) -> CcxtBroker:
+        exchange_class = getattr(ccxt_async, exchange_id)
+        exchange = exchange_class(
+            {"apiKey": api_key, "secret": api_secret, "enableRateLimit": True}
+        )
+        if testnet:
+            exchange.set_sandbox_mode(True)
+        return cls(exchange)
+
+    async def get_price(self, symbol: str) -> float:
+        ticker = await self._exchange.fetch_ticker(symbol)
+        return float(ticker["last"])
+
+    async def get_balances(self) -> dict[str, float]:
+        balance = await self._exchange.fetch_balance()
+        return {k: float(v) for k, v in balance.get("free", {}).items() if v}
+
+    async def place_market_order(
+        self, symbol: str, side: Side, quantity: float, *, client_order_id: str
+    ) -> Fill:
+        # clientOrderId is ccxt's unified param (newClientOrderId on Binance),
+        # which links the exchange order to the sealed IRL intent.
+        order = await self._exchange.create_order(
+            symbol, "market", side.value, quantity, None, {"clientOrderId": client_order_id}
+        )
+        fee = order.get("fee") or {}
+        return Fill(
+            order_id=str(order.get("id", "")),
+            symbol=symbol,
+            side=side,
+            quantity=float(order.get("filled") or quantity),
+            price=float(order.get("average") or order.get("price") or 0.0),
+            fee=float(fee.get("cost") or 0.0),
+            fee_asset=fee.get("currency"),
+        )
+
+    async def close(self) -> None:
+        await self._exchange.close()
+
+
+PriceSource = Callable[[str], Awaitable[float]]
+
+
+class PaperBroker(Broker):
+    """Simulated fills at live prices. No order ever leaves the process.
+
+    With ``state_path`` the balance sheet survives restarts: it is loaded from
+    that file when present (``balances`` then only seeds a new account) and
+    rewritten atomically after every fill. A state file that can't be read
+    is an error, never a silent reset to the starting balances.
+    """
+
+    def __init__(
+        self,
+        price_source: PriceSource,
+        balances: dict[str, float],
+        *,
+        venue_id: str = "paper",
+        fee_bps: float = 10.0,
+        slippage_bps: float = 5.0,
+        on_close: Callable[[], Awaitable[None]] | None = None,
+        state_path: str | os.PathLike[str] | None = None,
+    ):
+        self._price_source = price_source
+        self._state_path = Path(state_path) if state_path else None
+        if self._state_path is not None and self._state_path.exists():
+            self._balances = _load_balances(self._state_path)
+        else:
+            self._balances = {k.upper(): float(v) for k, v in balances.items()}
+        self.venue_id = venue_id
+        self._fee = fee_bps / 10_000
+        self._slip = slippage_bps / 10_000
+        self._on_close = on_close
+
+    async def get_price(self, symbol: str) -> float:
+        return await self._price_source(symbol)
+
+    async def get_balances(self) -> dict[str, float]:
+        return {k: v for k, v in self._balances.items() if v}
+
+    async def place_market_order(
+        self, symbol: str, side: Side, quantity: float, *, client_order_id: str
+    ) -> Fill:
+        if quantity <= 0:
+            raise ValueError("quantity must be positive")
+        base, quote = split_symbol(symbol)
+        mid = await self._price_source(symbol)
+        price = mid * (1 + self._slip) if side is Side.BUY else mid * (1 - self._slip)
+        gross = quantity * price
+        fee = gross * self._fee
+        if side is Side.BUY:
+            self._debit(quote, gross + fee)
+            self._credit(base, quantity)
+        else:
+            self._debit(base, quantity)
+            self._credit(quote, gross - fee)
+        self._save()
+        return Fill(
+            order_id=f"paper-{uuid.uuid4().hex[:16]}",
+            symbol=symbol,
+            side=side,
+            quantity=quantity,
+            price=price,
+            fee=fee,
+            fee_asset=quote,
+        )
+
+    def _debit(self, asset: str, amount: float) -> None:
+        available = self._balances.get(asset, 0.0)
+        if amount > available + 1e-12:
+            raise ValueError(f"insufficient {asset}: need {amount:.8f}, have {available:.8f}")
+        self._balances[asset] = available - amount
+
+    def _credit(self, asset: str, amount: float) -> None:
+        self._balances[asset] = self._balances.get(asset, 0.0) + amount
+
+    async def close(self) -> None:
+        if self._on_close is not None:
+            await self._on_close()
+
+    def _save(self) -> None:
+        if self._state_path is None:
+            return
+        self._state_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self._state_path.with_name(self._state_path.name + ".tmp")
+        tmp.write_text(json.dumps({"balances": self._balances}, sort_keys=True), encoding="utf-8")
+        os.replace(tmp, self._state_path)
+
+
+def _load_balances(path: Path) -> dict[str, float]:
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+        balances = raw["balances"]
+        parsed = {str(k).upper(): float(v) for k, v in balances.items()}
+    except (OSError, ValueError, KeyError, TypeError, AttributeError) as exc:
+        raise ValueError(f"paper state {path} is unreadable; fix or remove it: {exc}") from exc
+    if any(v < 0 for v in parsed.values()):
+        raise ValueError(f"paper state {path} has negative balances")
+    return parsed
+
+
+def public_price_source(
+    exchange_id: str = "binance",
+) -> tuple[PriceSource, Callable[[], Awaitable[None]]]:
+    """Live last-trade prices from an exchange's public API (no keys)."""
+    exchange = getattr(ccxt_async, exchange_id)({"enableRateLimit": True})
+
+    async def price(symbol: str) -> float:
+        ticker = await exchange.fetch_ticker(symbol)
+        return float(ticker["last"])
+
+    return price, exchange.close