irl-sdk 0.1.0__tar.gz

irl_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: irl-sdk
+Version: 0.1.0
+Summary: Python SDK for the IRL Engine — cryptographic pre-execution compliance rail
+Author-email: MacroPulse <hello@macropulse.live>
+License: MIT
+Keywords: ai,compliance,crypto,fintech,trading
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=42
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: respx; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# irl-sdk — Python SDK for the IRL Engine
+
+Async Python client for the [IRL Engine](https://irl.macropulse.live) — the cryptographic
+pre-execution compliance gateway for autonomous AI trading agents.
+
+- Fetches a signed Layer 2 heartbeat from the MTA operator automatically
+- Constructs and signs the authorize request
+- Returns a sealed `trace_id` and `reasoning_hash` before any order reaches the exchange
+
+## Install
+
+```bash
+pip install irl-sdk
+```
+
+Requires Python 3.10+.
+
+## Quick Start
+
+```python
+import asyncio
+from irl_sdk import IRLClient, AuthorizeRequest, TradeAction, OrderType
+
+IRL_URL   = "https://irl.macropulse.live"
+MTA_URL   = "https://api.macropulse.live"
+API_TOKEN = "your-irl-api-token"
+AGENT_ID  = "your-agent-uuid"           # from POST /irl/agents
+MODEL_HASH = "your-model-sha256-hex"    # 64-char hex
+
+async def main():
+    async with IRLClient(IRL_URL, API_TOKEN, MTA_URL) as client:
+        req = AuthorizeRequest(
+            agent_id=AGENT_ID,
+            model_id="my-model-v1",
+            model_hash_hex=MODEL_HASH,
+            action=TradeAction.LONG,
+            asset="BTC-USD",
+            order_type=OrderType.MARKET,
+            venue_id="coinbase",
+            quantity=0.1,
+            notional=6500.0,
+            notional_currency="USD",
+        )
+        result = await client.authorize(req)
+
+        if result.authorized:
+            print(f"AUTHORIZED  trace_id={result.trace_id}")
+            print(f"reasoning_hash={result.reasoning_hash[:24]}...")
+            # embed trace_id in your exchange order metadata, then place the order
+        else:
+            print("HALTED — IRL blocked the trade")
+
+asyncio.run(main())
+```
+
+## End-to-End Demo
+
+The demo registers nothing — it uses a pre-seeded demo agent in the public sandbox:
+
+```bash
+cd examples
+pip install -e ..
+python demo_e2e.py
+```
+
+Expected output:
+```
+IRL Engine : https://irl.macropulse.live
+MTA        : https://api.macropulse.live
+Agent ID   : 00000000-0000-4000-a000-000000000001
+
+Fetching heartbeat and submitting authorize request...
+
+AUTHORIZED
+  trace_id      : <uuid>
+  reasoning_hash: <first 24 chars>...
+  shadow_blocked: False
+```
+
+## API Reference
+
+### `IRLClient(irl_url, api_token, mta_url)`
+
+Async context manager. All parameters are positional.
+
+| Parameter | Description |
+|-----------|-------------|
+| `irl_url` | IRL Engine base URL |
+| `api_token` | Bearer token (from `IRL_API_TOKENS` env on the engine) |
+| `mta_url` | MTA operator URL for heartbeat fetch. Pass empty string `""` when `LAYER2_ENABLED=false`. |
+
+### `client.authorize(req: AuthorizeRequest) → AuthorizeResult`
+
+1. Fetches a fresh signed heartbeat from `{mta_url}/v1/irl/heartbeat`
+2. POSTs to `{irl_url}/irl/authorize` with the heartbeat and request payload
+3. Returns `AuthorizeResult`
+
+### `AuthorizeRequest` fields
+
+| Field | Type | Required | Notes |
+|-------|------|----------|-------|
+| `agent_id` | str | yes | UUID registered via `POST /irl/agents` |
+| `model_id` | str | yes | Human-readable model name |
+| `model_hash_hex` | str | yes | SHA-256 of model config (64 hex chars) |
+| `action` | TradeAction | yes | `LONG` / `SHORT` / `NEUTRAL` |
+| `asset` | str | yes | e.g. `"BTC-USD"`, `"SPY"` |
+| `order_type` | OrderType | yes | `MARKET` / `LIMIT` / `STOP` / `TWAP` / `VWAP` |
+| `venue_id` | str | yes | Exchange identifier |
+| `quantity` | float | yes | Order size |
+| `notional` | float | yes | Notional value |
+| `notional_currency` | str | yes | e.g. `"USD"` |
+| `client_order_id` | str | no | Your internal order reference |
+| `agent_valid_time` | int | no | Model inference timestamp (ms). Defaults to now. |
+
+### `AuthorizeResult` fields
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `trace_id` | str | UUID — embed in exchange order metadata |
+| `reasoning_hash` | str | SHA-256 seal of the full cognitive snapshot |
+| `authorized` | bool | `True` = proceed; `False` = halted by policy |
+| `shadow_blocked` | bool | `True` = would have been blocked; only set when `SHADOW_MODE=true` on the engine |
+
+### `TradeAction`
+
+```python
+from irl_sdk import TradeAction
+
+TradeAction.LONG     # "Long"
+TradeAction.SHORT    # "Short"
+TradeAction.NEUTRAL  # "Neutral"
+```
+
+### `OrderType`
+
+```python
+from irl_sdk import OrderType
+
+OrderType.MARKET  # "MARKET"
+OrderType.LIMIT   # "LIMIT"
+OrderType.STOP    # "STOP"
+OrderType.TWAP    # "TWAP"
+OrderType.VWAP    # "VWAP"
+```
+
+## Error Handling
+
+The SDK raises `httpx.HTTPStatusError` on non-2xx responses. The response body
+contains `{"error": "ERROR_CODE", "message": "..."}`. Common codes:
+
+| Code | Meaning |
+|------|---------|
+| `HEARTBEAT_DRIFT_EXCEEDED` | Heartbeat too old — clock skew or slow network |
+| `HEARTBEAT_MTA_REF_MISMATCH` | MTA hash mismatch — regime changed between heartbeat and authorize |
+| `REGIME_VIOLATION` | Action not permitted in current regime |
+| `NOTIONAL_EXCEEDS_LIMIT` | Exceeds agent notional cap × regime scale |
+| `MODEL_HASH_MISMATCH` | Provided hash ≠ registered hash |
+| `AGENT_NOT_FOUND` | Register the agent first via `POST /irl/agents` |
+
+## Layer 2 (Heartbeat) Details
+
+When `LAYER2_ENABLED=true` on the engine (default), every authorize request must
+carry a `SignedHeartbeat`. The SDK fetches this automatically from `{mta_url}/v1/irl/heartbeat`.
+
+The heartbeat binds each request to a specific MTA broadcast:
+- `sequence_id` — strictly monotone (anti-replay)
+- `timestamp_ms` — must be within `MAX_HEARTBEAT_DRIFT_MS` of `txn_time`
+- `mta_ref` — SHA-256 of the raw `/v1/regime/current` HTTP response body
+- `signature` — Ed25519 signature by the MTA operator
+
+For local dev with `LAYER2_ENABLED=false`, pass `mta_url=""`. The engine
+substitutes a zero heartbeat internally.
+
+## License
+
+MIT

irl_sdk-0.1.0/README.md

@@ -0,0 +1,176 @@
+# irl-sdk — Python SDK for the IRL Engine
+
+Async Python client for the [IRL Engine](https://irl.macropulse.live) — the cryptographic
+pre-execution compliance gateway for autonomous AI trading agents.
+
+- Fetches a signed Layer 2 heartbeat from the MTA operator automatically
+- Constructs and signs the authorize request
+- Returns a sealed `trace_id` and `reasoning_hash` before any order reaches the exchange
+
+## Install
+
+```bash
+pip install irl-sdk
+```
+
+Requires Python 3.10+.
+
+## Quick Start
+
+```python
+import asyncio
+from irl_sdk import IRLClient, AuthorizeRequest, TradeAction, OrderType
+
+IRL_URL   = "https://irl.macropulse.live"
+MTA_URL   = "https://api.macropulse.live"
+API_TOKEN = "your-irl-api-token"
+AGENT_ID  = "your-agent-uuid"           # from POST /irl/agents
+MODEL_HASH = "your-model-sha256-hex"    # 64-char hex
+
+async def main():
+    async with IRLClient(IRL_URL, API_TOKEN, MTA_URL) as client:
+        req = AuthorizeRequest(
+            agent_id=AGENT_ID,
+            model_id="my-model-v1",
+            model_hash_hex=MODEL_HASH,
+            action=TradeAction.LONG,
+            asset="BTC-USD",
+            order_type=OrderType.MARKET,
+            venue_id="coinbase",
+            quantity=0.1,
+            notional=6500.0,
+            notional_currency="USD",
+        )
+        result = await client.authorize(req)
+
+        if result.authorized:
+            print(f"AUTHORIZED  trace_id={result.trace_id}")
+            print(f"reasoning_hash={result.reasoning_hash[:24]}...")
+            # embed trace_id in your exchange order metadata, then place the order
+        else:
+            print("HALTED — IRL blocked the trade")
+
+asyncio.run(main())
+```
+
+## End-to-End Demo
+
+The demo registers nothing — it uses a pre-seeded demo agent in the public sandbox:
+
+```bash
+cd examples
+pip install -e ..
+python demo_e2e.py
+```
+
+Expected output:
+```
+IRL Engine : https://irl.macropulse.live
+MTA        : https://api.macropulse.live
+Agent ID   : 00000000-0000-4000-a000-000000000001
+
+Fetching heartbeat and submitting authorize request...
+
+AUTHORIZED
+  trace_id      : <uuid>
+  reasoning_hash: <first 24 chars>...
+  shadow_blocked: False
+```
+
+## API Reference
+
+### `IRLClient(irl_url, api_token, mta_url)`
+
+Async context manager. All parameters are positional.
+
+| Parameter | Description |
+|-----------|-------------|
+| `irl_url` | IRL Engine base URL |
+| `api_token` | Bearer token (from `IRL_API_TOKENS` env on the engine) |
+| `mta_url` | MTA operator URL for heartbeat fetch. Pass empty string `""` when `LAYER2_ENABLED=false`. |
+
+### `client.authorize(req: AuthorizeRequest) → AuthorizeResult`
+
+1. Fetches a fresh signed heartbeat from `{mta_url}/v1/irl/heartbeat`
+2. POSTs to `{irl_url}/irl/authorize` with the heartbeat and request payload
+3. Returns `AuthorizeResult`
+
+### `AuthorizeRequest` fields
+
+| Field | Type | Required | Notes |
+|-------|------|----------|-------|
+| `agent_id` | str | yes | UUID registered via `POST /irl/agents` |
+| `model_id` | str | yes | Human-readable model name |
+| `model_hash_hex` | str | yes | SHA-256 of model config (64 hex chars) |
+| `action` | TradeAction | yes | `LONG` / `SHORT` / `NEUTRAL` |
+| `asset` | str | yes | e.g. `"BTC-USD"`, `"SPY"` |
+| `order_type` | OrderType | yes | `MARKET` / `LIMIT` / `STOP` / `TWAP` / `VWAP` |
+| `venue_id` | str | yes | Exchange identifier |
+| `quantity` | float | yes | Order size |
+| `notional` | float | yes | Notional value |
+| `notional_currency` | str | yes | e.g. `"USD"` |
+| `client_order_id` | str | no | Your internal order reference |
+| `agent_valid_time` | int | no | Model inference timestamp (ms). Defaults to now. |
+
+### `AuthorizeResult` fields
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `trace_id` | str | UUID — embed in exchange order metadata |
+| `reasoning_hash` | str | SHA-256 seal of the full cognitive snapshot |
+| `authorized` | bool | `True` = proceed; `False` = halted by policy |
+| `shadow_blocked` | bool | `True` = would have been blocked; only set when `SHADOW_MODE=true` on the engine |
+
+### `TradeAction`
+
+```python
+from irl_sdk import TradeAction
+
+TradeAction.LONG     # "Long"
+TradeAction.SHORT    # "Short"
+TradeAction.NEUTRAL  # "Neutral"
+```
+
+### `OrderType`
+
+```python
+from irl_sdk import OrderType
+
+OrderType.MARKET  # "MARKET"
+OrderType.LIMIT   # "LIMIT"
+OrderType.STOP    # "STOP"
+OrderType.TWAP    # "TWAP"
+OrderType.VWAP    # "VWAP"
+```
+
+## Error Handling
+
+The SDK raises `httpx.HTTPStatusError` on non-2xx responses. The response body
+contains `{"error": "ERROR_CODE", "message": "..."}`. Common codes:
+
+| Code | Meaning |
+|------|---------|
+| `HEARTBEAT_DRIFT_EXCEEDED` | Heartbeat too old — clock skew or slow network |
+| `HEARTBEAT_MTA_REF_MISMATCH` | MTA hash mismatch — regime changed between heartbeat and authorize |
+| `REGIME_VIOLATION` | Action not permitted in current regime |
+| `NOTIONAL_EXCEEDS_LIMIT` | Exceeds agent notional cap × regime scale |
+| `MODEL_HASH_MISMATCH` | Provided hash ≠ registered hash |
+| `AGENT_NOT_FOUND` | Register the agent first via `POST /irl/agents` |
+
+## Layer 2 (Heartbeat) Details
+
+When `LAYER2_ENABLED=true` on the engine (default), every authorize request must
+carry a `SignedHeartbeat`. The SDK fetches this automatically from `{mta_url}/v1/irl/heartbeat`.
+
+The heartbeat binds each request to a specific MTA broadcast:
+- `sequence_id` — strictly monotone (anti-replay)
+- `timestamp_ms` — must be within `MAX_HEARTBEAT_DRIFT_MS` of `txn_time`
+- `mta_ref` — SHA-256 of the raw `/v1/regime/current` HTTP response body
+- `signature` — Ed25519 signature by the MTA operator
+
+For local dev with `LAYER2_ENABLED=false`, pass `mta_url=""`. The engine
+substitutes a zero heartbeat internally.
+
+## License
+
+MIT

irl_sdk-0.1.0/examples/demo_e2e.py

@@ -0,0 +1,61 @@
+"""
+IRL SDK — end-to-end demo.
+
+Registers an agent in the IRL Engine MAR (if not already present) and
+submits a test trade intent for authorization.
+
+Usage:
+    pip install -e ..
+    python demo_e2e.py
+"""
+
+import asyncio
+import hashlib
+import os
+
+from irl_sdk import IRLClient, AuthorizeRequest, TradeAction, OrderType
+
+IRL_URL = os.getenv("IRL_URL", "https://irl.macropulse.live")
+MTA_URL = os.getenv("MTA_URL", "https://api.macropulse.live")
+API_TOKEN = os.getenv("IRL_API_TOKEN", "demo-readonly-1a1bb53fb4bcb5f1ca2c2f48808a35ba")
+
+# Stable demo agent — must be registered in the IRL Engine MAR.
+AGENT_ID = "00000000-0000-4000-a000-000000000001"  # demo-crypto-agent in MAR
+MODEL_HASH = "cee60d4e409bd88b5e1998ef6ac078498491616a3a321bc76399b94784c4f283"  # sha256(b"demo-crypto-agent-v1")
+
+
+async def main() -> None:
+    print(f"IRL Engine : {IRL_URL}")
+    print(f"MTA        : {MTA_URL}")
+    print(f"Agent ID   : {AGENT_ID}")
+    print(f"Model hash : {MODEL_HASH[:16]}...")
+    print()
+
+    async with IRLClient(IRL_URL, API_TOKEN, MTA_URL) as client:
+        req = AuthorizeRequest(
+            agent_id=AGENT_ID,
+            model_id="demo-algo-v1",
+            model_hash_hex=MODEL_HASH,
+            action=TradeAction.LONG,
+            asset="BTC-USD",
+            order_type=OrderType.MARKET,
+            venue_id="coinbase",
+            quantity=0.01,
+            notional=650.0,
+            notional_currency="USD",
+        )
+
+        print("Fetching heartbeat and submitting authorize request...")
+        try:
+            result = await client.authorize(req)
+            print()
+            print("AUTHORIZED" if result.authorized else "HALTED")
+            print(f"  trace_id      : {result.trace_id}")
+            print(f"  reasoning_hash: {result.reasoning_hash[:24]}...")
+            print(f"  shadow_blocked: {result.shadow_blocked}")
+        except Exception as exc:
+            print(f"ERROR: {exc}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

irl_sdk-0.1.0/irl_sdk/__init__.py

@@ -0,0 +1,6 @@
+"""IRL SDK — Python client for the IRL Engine compliance rail."""
+
+from .client import IRLClient
+from .models import AuthorizeRequest, AuthorizeResult, TradeAction, OrderType
+
+__all__ = ["IRLClient", "AuthorizeRequest", "AuthorizeResult", "TradeAction", "OrderType"]

irl_sdk-0.1.0/irl_sdk/client.py

@@ -0,0 +1,144 @@
+"""
+IRLClient — send authorized trade intents to the IRL Engine.
+
+Usage:
+    client = IRLClient(
+        irl_url="https://irl.macropulse.live",
+        api_token="your-token",
+        mta_url="https://api.macropulse.live",
+    )
+
+    result = await client.authorize(
+        AuthorizeRequest(
+            agent_id="550e8400-e29b-41d4-a716-446655440000",
+            model_id="my-algo-v1",
+            model_hash_hex="abc123...",
+            action=TradeAction.LONG,
+            asset="BTC-USD",
+            quantity=0.1,
+            notional=6500.0,
+        )
+    )
+
+    print(result.trace_id, result.authorized)
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+import httpx
+
+from .models import AuthorizeRequest, AuthorizeResult
+
+
+class IRLClient:
+    """Async client for the IRL Engine /irl/authorize endpoint.
+
+    Fetches a fresh heartbeat from MacroPulse before each authorize call
+    and attaches it automatically. The heartbeat ensures L2 anti-replay
+    compliance — do not cache or reuse heartbeats across requests.
+    """
+
+    def __init__(
+        self,
+        irl_url: str,
+        api_token: str,
+        mta_url: str,
+        timeout: float = 5.0,
+    ) -> None:
+        self._irl_url = irl_url.rstrip("/")
+        self._mta_url = mta_url.rstrip("/")
+        self._headers = {"Authorization": f"Bearer {api_token}"}
+        self._http = httpx.AsyncClient(timeout=timeout)
+
+    async def authorize(self, req: AuthorizeRequest) -> AuthorizeResult:
+        """Fetch a fresh heartbeat and submit a trade intent for authorization.
+
+        Raises:
+            httpx.HTTPStatusError: on 4xx/5xx from IRL Engine
+            RuntimeError: if heartbeat fetch fails
+        """
+        hb = await self._fetch_heartbeat()
+
+        if req.agent_valid_time == 0:
+            req.agent_valid_time = int(time.time() * 1000)
+
+        body = self._build_body(req, hb)
+
+        resp = await self._http.post(
+            f"{self._irl_url}/irl/authorize",
+            json=body,
+            headers=self._headers,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        return AuthorizeResult(
+            trace_id=data["trace_id"],
+            reasoning_hash=data["reasoning_hash"],
+            authorized=data["authorized"],
+            shadow_blocked=data.get("shadow_blocked", False),
+        )
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "IRLClient":
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.close()
+
+    async def _fetch_heartbeat(self) -> dict:
+        resp = await self._http.get(f"{self._mta_url}/v1/irl/heartbeat")
+        if resp.status_code != 200:
+            raise RuntimeError(
+                f"Failed to fetch heartbeat: HTTP {resp.status_code} — {resp.text}"
+            )
+        return resp.json()
+
+    def _build_body(self, req: AuthorizeRequest, heartbeat: dict) -> dict:
+        # Match the AuthorizeRequest JSON schema expected by the IRL Engine.
+        # TradeAction variants are serialized as tagged JSON: {"Long": qty}
+        action_value: object
+        if req.action.value == "Long":
+            action_value = {"Long": req.quantity}
+        elif req.action.value == "Short":
+            action_value = {"Short": req.quantity}
+        elif req.action.value == "Neutral":
+            action_value = "Neutral"
+        else:
+            action_value = req.action.value
+
+        body: dict = {
+            "agent_id": req.agent_id,
+            "model_id": req.model_id,
+            "model_hash_hex": req.model_hash_hex,
+            "prompt_version": req.prompt_version,
+            "feature_schema_id": req.feature_schema_id,
+            "hyperparameter_checksum": req.hyperparameter_checksum,
+            "action": action_value,
+            "asset": req.asset,
+            "order_type": req.order_type.value,
+            "venue_id": req.venue_id,
+            "quantity": req.quantity,
+            "notional": req.notional,
+            "notional_currency": req.notional_currency,
+            "multiplier": req.multiplier,
+            "reduce_only": req.reduce_only,
+            "agent_valid_time": req.agent_valid_time,
+            "heartbeat": heartbeat,
+        }
+
+        body["client_order_id"] = req.client_order_id or ""
+
+        if req.limit_price is not None:
+            body["limit_price"] = req.limit_price
+        if req.stop_price is not None:
+            body["stop_price"] = req.stop_price
+        if req.regulatory is not None:
+            body["regulatory"] = req.regulatory
+
+        return body

irl_sdk-0.1.0/irl_sdk/models.py

@@ -0,0 +1,61 @@
+"""Data models matching the IRL Engine wire format."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class TradeAction(str, Enum):
+    LONG = "Long"
+    SHORT = "Short"
+    NEUTRAL = "Neutral"
+
+
+class OrderType(str, Enum):
+    MARKET = "MARKET"
+    LIMIT = "LIMIT"
+    STOP = "STOP"
+    STOP_LIMIT = "STOP_LIMIT"
+    TWAP = "TWAP"
+
+
+@dataclass
+class AuthorizeRequest:
+    # Agent identity
+    agent_id: str                    # UUID string — must be registered in the MAR
+    model_id: str                    # Human-readable model identifier
+    model_hash_hex: str              # SHA-256 of the agent's model weights (hex)
+    prompt_version: str = "v1"
+    feature_schema_id: str = "default"
+    hyperparameter_checksum: str = "0" * 64
+
+    # Trade intent
+    action: TradeAction = TradeAction.NEUTRAL
+    asset: str = ""
+    order_type: OrderType = OrderType.MARKET
+    venue_id: str = ""
+    quantity: float = 0.0
+    notional: float = 0.0
+    notional_currency: str = "USD"
+    multiplier: float = 1.0
+    limit_price: Optional[float] = None
+    stop_price: Optional[float] = None
+    client_order_id: Optional[str] = None
+    reduce_only: bool = False
+
+    # Temporal context
+    agent_valid_time: int = 0        # Unix ms of the agent's decision time
+
+    # Filled automatically by IRLClient.authorize()
+    heartbeat: Optional[dict] = None
+    regulatory: Optional[dict] = None
+
+
+@dataclass
+class AuthorizeResult:
+    trace_id: str
+    reasoning_hash: str
+    authorized: bool
+    shadow_blocked: bool

irl_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "irl-sdk"
+version = "0.1.0"
+description = "Python SDK for the IRL Engine — cryptographic pre-execution compliance rail"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "MacroPulse", email = "hello@macropulse.live"},
+]
+keywords = ["trading", "compliance", "ai", "crypto", "fintech"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx>=0.27",
+    "cryptography>=42",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio", "respx"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["irl_sdk"]