blockfill 0.1.0__py3-none-any.whl

blockfill/__init__.py

@@ -0,0 +1,24 @@
+from .client import Blockfill
+from .exceptions import (
+    BinaryNotFound,
+    CredentialsError,
+    DaemonNotRunning,
+    DaemonStartTimeout,
+    InstallError,
+    RpcError,
+    TicketNotFound,
+)
+from .models import DaemonStatus, Ticket
+
+__all__ = [
+    "Blockfill",
+    "Ticket",
+    "DaemonStatus",
+    "BinaryNotFound",
+    "CredentialsError",
+    "DaemonNotRunning",
+    "DaemonStartTimeout",
+    "InstallError",
+    "RpcError",
+    "TicketNotFound",
+]

blockfill/client.py

@@ -0,0 +1,218 @@
+import subprocess
+from pathlib import Path
+from typing import Self
+
+from . import config as _config
+from . import daemon as _daemon
+from . import installer as _installer
+from . import rpc
+from .exceptions import BinaryNotFound, DaemonNotRunning, TicketNotFound
+from .models import DaemonStatus, Ticket
+
+
+def _parse_ticket(raw: dict, defaults: dict | None = None) -> Ticket:
+    # Daemon may return a partial response (place returns only ticket_id/status/exchange/symbol/target_position).
+    # Merge in any caller-supplied defaults for fields not present in the response.
+    d = {**(defaults or {}), **raw}
+    return Ticket(
+        ticket_id=d["ticket_id"],
+        status=d["status"],
+        exchange=d["exchange"],
+        symbol=d["symbol"],
+        strategy=d.get("strategy", ""),
+        target_position=d["target_position"],
+        executed_position=d.get("executed_position"),
+        time_constraint_ms=d.get("time_constraint_ms", 0),
+        start_time_ms=d.get("start_time_ms"),
+        last_update_time_ms=d.get("last_update_time_ms"),
+        is_expired=d.get("is_expired", False),
+        cancel_reason=d.get("cancel_reason"),
+    )
+
+
+class Blockfill:
+    def __init__(
+        self,
+        data_dir: str | Path = "~/.blockfill",
+        binary_path: str | Path | None = None,
+        timeout_s: float = 10.0,
+    ) -> None:
+        self._data_dir = Path(data_dir).expanduser()
+        self._timeout_s = timeout_s
+
+        if binary_path is not None:
+            self._binary = Path(binary_path).expanduser()
+        else:
+            self._binary = self._data_dir / "bin" / "blockfill"
+
+        self._config_path = self._data_dir / "config.toml"
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _sock(self) -> Path:
+        return _daemon.sock_path(self._data_dir)
+
+    def _require_binary(self) -> None:
+        if not self._binary.exists():
+            raise BinaryNotFound(
+                f"blockfill binary not found at {self._binary}. Run install() first."
+            )
+
+    def _require_daemon(self) -> None:
+        if not self._sock().exists():
+            raise DaemonNotRunning(f"daemon socket not found at {self._sock()}")
+
+    # ------------------------------------------------------------------
+    # Install & version
+    # ------------------------------------------------------------------
+
+    def install(self, version: str = "latest", force: bool = False) -> str:
+        return _installer.install(self._binary, version=version, force=force)
+
+    def version(self) -> str:
+        self._require_binary()
+        return _installer.version_from_binary(self._binary)
+
+    # ------------------------------------------------------------------
+    # Credentials & config
+    # ------------------------------------------------------------------
+
+    def set_credentials(
+        self,
+        exchange: str,
+        api_key: str,
+        api_secret: str,
+        api_passphrase: str | None = None,
+    ) -> None:
+        _config.set_credentials(
+            self._config_path,
+            exchange=exchange,
+            api_key=api_key,
+            api_secret=api_secret,
+            api_passphrase=api_passphrase,
+        )
+
+    def set_qtex_endpoint(self, endpoint: str) -> None:
+        _config.set_qtex_endpoint(self._config_path, endpoint)
+
+    # ------------------------------------------------------------------
+    # Daemon management
+    # ------------------------------------------------------------------
+
+    def is_running(self) -> bool:
+        return _daemon.is_running(self._data_dir, timeout_s=2.0)
+
+    def start(
+        self,
+        wait_timeout_s: float = 10.0,
+        env: dict | None = None,
+    ) -> None:
+        self._require_binary()
+        _daemon.start(self._binary, self._data_dir, wait_timeout_s=wait_timeout_s, env=env)
+
+    def stop(self, wait_timeout_s: float = 5.0) -> None:
+        _daemon.stop(self._data_dir, wait_timeout_s=wait_timeout_s)
+
+    def restart(self) -> None:
+        self.stop()
+        self.start()
+
+    def health(self) -> DaemonStatus:
+        return _daemon.health(self._data_dir, timeout_s=self._timeout_s)
+
+    def run_foreground(self, env: dict | None = None) -> None:
+        self._require_binary()
+        import os
+        merged_env = {**os.environ, **(env or {})}
+        subprocess.run(
+            [str(self._binary), "--data-dir", str(self._data_dir), "run"],
+            env=merged_env,
+        )
+
+    # ------------------------------------------------------------------
+    # Ticket operations (UDS RPC)
+    # ------------------------------------------------------------------
+
+    def place(
+        self,
+        exchange: str,
+        symbol: str,
+        strategy: str,
+        target_position: float,
+        time_constraint_ms: int,
+        client_ticket_id: str | None = None,
+    ) -> Ticket:
+        self._require_daemon()
+        params: dict = {
+            "exchange": exchange,
+            "symbol": symbol,
+            "strategy": strategy,
+            "target_position": target_position,
+            "time_constraint_ms": time_constraint_ms,
+        }
+        if client_ticket_id is not None:
+            params["client_ticket_id"] = client_ticket_id
+
+        result = rpc.call(self._sock(), "ticket.place", params, timeout_s=self._timeout_s)
+        return _parse_ticket(result, defaults=params)
+
+    def query(
+        self,
+        status: str | None = None,
+        symbol: str | None = None,
+        ticket_id: str | None = None,
+        from_ms: int | None = None,
+        to_ms: int | None = None,
+        limit: int = 100,
+    ) -> list[Ticket]:
+        self._require_daemon()
+        params: dict = {"limit": limit}
+        if status is not None:
+            params["status"] = status
+        if symbol is not None:
+            params["symbol"] = symbol
+        if ticket_id is not None:
+            params["ticket_id"] = ticket_id
+        if from_ms is not None:
+            params["from_ms"] = from_ms
+        if to_ms is not None:
+            params["to_ms"] = to_ms
+
+        result = rpc.call(self._sock(), "ticket.query", params, timeout_s=self._timeout_s)
+        tickets = result if isinstance(result, list) else result.get("tickets", [])
+        return [_parse_ticket(t) for t in tickets]
+
+    def cancel(self, ticket_id: str) -> None:
+        self._require_daemon()
+        try:
+            rpc.call(
+                self._sock(),
+                "ticket.cancel",
+                {"ticket_id": ticket_id},
+                timeout_s=self._timeout_s,
+            )
+        except Exception as e:
+            # Surface TicketNotFound if the daemon signals it
+            msg = str(e).lower()
+            if "not found" in msg or "404" in msg:
+                raise TicketNotFound(ticket_id) from e
+            raise
+
+    def cancel_all(self) -> int:
+        self._require_daemon()
+        result = rpc.call(self._sock(), "ticket.cancel_all", timeout_s=self._timeout_s)
+        if isinstance(result, int):
+            return result
+        return result.get("canceled", 0)
+
+    # ------------------------------------------------------------------
+    # Context manager
+    # ------------------------------------------------------------------
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_) -> None:
+        self.stop()

blockfill/config.py

@@ -0,0 +1,48 @@
+import os
+import stat
+from pathlib import Path
+
+import toml
+
+from .exceptions import CredentialsError
+
+
+def _load_toml(config_path: Path) -> dict:
+    if config_path.exists():
+        return toml.loads(config_path.read_text())
+    return {}
+
+
+def _save_toml(config_path: Path, data: dict) -> None:
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(toml.dumps(data))
+    os.chmod(config_path, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def set_credentials(
+    config_path: Path,
+    exchange: str,
+    api_key: str,
+    api_secret: str,
+    api_passphrase: str | None = None,
+) -> None:
+    valid_exchanges = {"binance-futures", "okx-swap"}
+    if exchange not in valid_exchanges:
+        raise CredentialsError(f"Unknown exchange: {exchange!r}. Valid: {valid_exchanges}")
+
+    data = _load_toml(config_path)
+    if "exchanges" not in data:
+        data["exchanges"] = {}
+    entry: dict = {"api_key": api_key, "api_secret": api_secret}
+    if api_passphrase is not None:
+        entry["api_passphrase"] = api_passphrase
+    data["exchanges"][exchange] = entry
+    _save_toml(config_path, data)
+
+
+def set_qtex_endpoint(config_path: Path, endpoint: str) -> None:
+    data = _load_toml(config_path)
+    if "qtex" not in data:
+        data["qtex"] = {}
+    data["qtex"]["endpoint"] = endpoint
+    _save_toml(config_path, data)

blockfill/daemon.py

@@ -0,0 +1,90 @@
+import os
+import subprocess
+import time
+from pathlib import Path
+
+from . import rpc
+from .exceptions import DaemonNotRunning, DaemonStartTimeout
+from .models import DaemonStatus
+
+
+def sock_path(data_dir: Path) -> Path:
+    return data_dir / "runtime" / "daemon.sock"
+
+
+def is_running(data_dir: Path, timeout_s: float = 2.0) -> bool:
+    sp = sock_path(data_dir)
+    if not sp.exists():
+        return False
+    try:
+        rpc.call(sp, "system.status", timeout_s=timeout_s)
+        return True
+    except Exception:
+        return False
+
+
+def start(
+    binary_path: Path,
+    data_dir: Path,
+    wait_timeout_s: float = 10.0,
+    env: dict | None = None,
+) -> None:
+    if is_running(data_dir):
+        return
+
+    merged_env = {**os.environ, **(env or {})}
+    subprocess.Popen(
+        [str(binary_path), "--data-dir", str(data_dir), "run"],
+        env=merged_env,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    deadline = time.monotonic() + wait_timeout_s
+    while time.monotonic() < deadline:
+        if is_running(data_dir, timeout_s=1.0):
+            return
+        time.sleep(0.25)
+
+    raise DaemonStartTimeout(
+        f"daemon did not become ready within {wait_timeout_s}s "
+        f"(sock: {sock_path(data_dir)})"
+    )
+
+
+def stop(data_dir: Path, wait_timeout_s: float = 5.0) -> None:
+    sp = sock_path(data_dir)
+    if not sp.exists():
+        return
+
+    try:
+        rpc.call(sp, "system.shutdown", timeout_s=3.0)
+    except Exception:
+        # If daemon is already gone or RPC fails, proceed to wait for socket removal
+        pass
+
+    deadline = time.monotonic() + wait_timeout_s
+    while time.monotonic() < deadline:
+        if not sp.exists():
+            return
+        time.sleep(0.25)
+
+
+def health(data_dir: Path, timeout_s: float = 10.0) -> DaemonStatus:
+    sp = sock_path(data_dir)
+    if not sp.exists():
+        raise DaemonNotRunning(f"daemon socket not found at {sp}")
+
+    try:
+        result = rpc.call(sp, "system.status", timeout_s=timeout_s)
+    except Exception as e:
+        raise DaemonNotRunning(f"cannot connect to daemon: {e}") from e
+
+    return DaemonStatus(
+        running=result.get("running", True),
+        pid=result.get("pid", 0),
+        exchanges=result.get("exchanges", []),
+        active_tickets=result.get("active_tickets", 0),
+        uptime_s=result.get("uptime_s", 0),
+        version=result.get("version", ""),
+    )

blockfill/exceptions.py

@@ -0,0 +1,29 @@
+class BinaryNotFound(Exception):
+    pass
+
+
+class DaemonNotRunning(Exception):
+    pass
+
+
+class DaemonStartTimeout(Exception):
+    pass
+
+
+class RpcError(Exception):
+    def __init__(self, code: int, message: str) -> None:
+        super().__init__(f"RPC error {code}: {message}")
+        self.code = code
+        self.message = message
+
+
+class TicketNotFound(Exception):
+    pass
+
+
+class CredentialsError(Exception):
+    pass
+
+
+class InstallError(Exception):
+    pass

blockfill/installer.py

@@ -0,0 +1,42 @@
+import platform
+import subprocess
+from pathlib import Path
+
+from .exceptions import BinaryNotFound, InstallError
+
+
+def _detect_platform() -> str:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "linux":
+        if machine in ("x86_64", "amd64"):
+            return "linux-amd64"
+        elif machine in ("aarch64", "arm64"):
+            return "linux-arm64"
+    elif system == "darwin":
+        return "darwin-arm64"
+
+    raise InstallError(f"Unsupported platform: {system}/{machine}")
+
+
+def install(binary_path: Path, version: str = "latest", force: bool = False) -> str:
+    if binary_path.exists() and not force:
+        # Already installed — return current version without downloading
+        return version_from_binary(binary_path)
+
+    _detect_platform()  # validate platform before attempting download
+    raise NotImplementedError("download not yet implemented")
+
+
+def version_from_binary(binary_path: Path) -> str:
+    if not binary_path.exists():
+        raise BinaryNotFound(f"blockfill binary not found at {binary_path}. Run install() first.")
+    result = subprocess.run(
+        [str(binary_path), "version"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise BinaryNotFound(f"blockfill version failed: {result.stderr.strip()}")
+    return result.stdout.strip()

blockfill/models.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class DaemonStatus:
+    running: bool
+    pid: int
+    exchanges: list[str]
+    active_tickets: int
+    uptime_s: int
+    version: str
+
+
+@dataclass
+class Ticket:
+    ticket_id: str
+    status: str
+    exchange: str
+    symbol: str
+    strategy: str
+    target_position: float
+    executed_position: float | None
+    time_constraint_ms: int
+    start_time_ms: int | None
+    last_update_time_ms: int | None
+    is_expired: bool
+    cancel_reason: str | None
+
+    def __str__(self) -> str:
+        parts = [f"{self.ticket_id} [{self.status}] {self.exchange}/{self.symbol}",
+                 f"target={self.target_position}"]
+        if self.executed_position is not None:
+            parts.append(f"executed={self.executed_position}")
+        if self.cancel_reason:
+            parts.append(f"cancel_reason={self.cancel_reason}")
+        if self.is_expired:
+            parts.append("EXPIRED")
+        return "  ".join(parts)

blockfill/rpc.py

@@ -0,0 +1,23 @@
+import json
+import socket
+from pathlib import Path
+
+from .exceptions import RpcError
+
+
+def call(sock_path: Path | str, method: str, params: dict | None = None, timeout_s: float = 10.0) -> dict:
+    req = json.dumps({"jsonrpc": "2.0", "method": method, "params": params or {}, "id": 1}) + "\n"
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+        s.settimeout(timeout_s)
+        s.connect(str(sock_path))
+        s.sendall(req.encode())
+        data = b""
+        while not data.endswith(b"\n"):
+            chunk = s.recv(4096)
+            if not chunk:
+                break
+            data += chunk
+    resp = json.loads(data.decode())
+    if "error" in resp:
+        raise RpcError(resp["error"]["code"], resp["error"]["message"])
+    return resp["result"]

blockfill-0.1.0.dist-info/METADATA

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: blockfill
+Version: 0.1.0
+Summary: Python SDK for the blockfill execution daemon
+Author-email: Mavri-X <robot@mavri-x.ai>
+License: Proprietary
+Project-URL: Homepage, https://github.com/mavri-x/blockfill
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: toml
+
+# blockfill Python SDK
+
+Python wrapper for the [blockfill](../executor/) execution daemon. Covers the full lifecycle: install binary, configure credentials, manage daemon, place/query/cancel tickets.
+
+## Requirements
+
+- Python 3.10+
+- blockfill binary (see [Install](#install))
+- blockfill daemon running (see [Daemon](#daemon))
+
+## Install
+
+```bash
+pip install blockfill
+# or from source
+pip install -e /path/to/python-sdk
+```
+
+## Quickstart
+
+```python
+from blockfill import Blockfill
+
+bf = Blockfill(
+    binary_path="/path/to/blockfill",   # or ~/.blockfill/bin/blockfill
+    data_dir="~/.blockfill",
+)
+
+# First-time setup
+bf.set_credentials("binance-futures", api_key="...", api_secret="...")
+bf.set_qtex_endpoint("https://qtex.example.com")
+
+# Start daemon
+bf.start(env={"BLOCKFILL_API_KEY": "..."})
+bf.health()
+
+# Place a ticket
+ticket = bf.place(
+    exchange="binance-futures",
+    symbol="btcusdt",
+    strategy="maker_l2",
+    target_position=0.1,
+    time_constraint_ms=300_000,
+)
+print(ticket.ticket_id, ticket.status)  # tkt_xxx NEW
+
+# Query
+tickets = bf.query(status="NEW")
+
+# Cancel
+bf.cancel(ticket.ticket_id)
+
+# Stop daemon
+bf.stop()
+```
+
+---
+
+## API Reference
+
+### `Blockfill(binary_path, data_dir, timeout_s)`
+
+| Parameter     | Default                      | Description                           |
+| ------------- | ---------------------------- | ------------------------------------- |
+| `binary_path` | `~/.blockfill/bin/blockfill` | Path to blockfill binary              |
+| `data_dir`    | `~/.blockfill`               | Data directory (config, socket, logs) |
+| `timeout_s`   | `10.0`                       | RPC call timeout (seconds)            |
+
+---
+
+### Install & Version
+
+```python
+bf.install(version="latest", force=False) -> str
+# Returns installed version string.
+# If binary already exists and force=False, skips download and returns current version.
+
+bf.version() -> str
+# Returns "blockfill 0.1.0"
+```
+
+---
+
+### Credentials
+
+```python
+bf.set_credentials(
+    exchange: str,            # "binance-futures" | "okx-swap"
+    api_key: str,
+    api_secret: str,
+    api_passphrase: str | None = None,  # OKX only
+) -> None
+# Writes to {data_dir}/config.toml (chmod 0600)
+
+bf.set_qtex_endpoint(endpoint: str) -> None
+# e.g. bf.set_qtex_endpoint("https://qtex.example.com")
+```
+
+---
+
+### Daemon
+
+```python
+bf.start(wait_timeout_s=10.0, env=None) -> None
+# Starts daemon in background. No-op if already running.
+# env: extra environment variables (e.g. {"BLOCKFILL_API_KEY": "..."})
+
+bf.stop(wait_timeout_s=5.0) -> None
+# Graceful shutdown. No-op if not running.
+
+bf.restart() -> None
+
+bf.is_running() -> bool
+
+bf.health() -> DaemonStatus
+# Raises DaemonNotRunning if daemon is not up.
+
+bf.run_foreground(env=None) -> None
+# Blocking. For dev/debug.
+```
+
+`DaemonStatus` fields: `running`, `pid`, `exchanges`, `active_tickets`, `uptime_s`, `version`
+
+---
+
+### Tickets
+
+```python
+bf.place(
+    exchange: str,
+    symbol: str,
+    strategy: str,
+    target_position: float,       # positive = buy, negative = sell
+    time_constraint_ms: int,
+    client_ticket_id: str | None = None,  # idempotency key
+) -> Ticket
+
+bf.query(
+    status: str | None = None,    # "NEW" | "OPEN" | "COMPLETE" | "CANCEL"
+    symbol: str | None = None,
+    ticket_id: str | None = None,
+    from_ms: int | None = None,
+    to_ms: int | None = None,
+    limit: int = 100,
+) -> list[Ticket]
+
+bf.cancel(ticket_id: str) -> None
+# Raises TicketNotFound if ticket doesn't exist.
+
+bf.cancel_all() -> int
+# Returns number of cancelled tickets.
+```
+
+`Ticket` fields: `ticket_id`, `status`, `exchange`, `symbol`, `strategy`, `target_position`, `executed_position`, `time_constraint_ms`, `start_time_ms`, `last_update_time_ms`, `is_expired`, `cancel_reason`
+
+**Auto-cancel**: placing a new ticket for the same `exchange+symbol` automatically cancels existing `NEW` tickets for that pair.
+
+---
+
+### Context Manager
+
+```python
+with Blockfill(binary_path=..., data_dir=...) as bf:
+    bf.start(env={"BLOCKFILL_API_KEY": "..."})
+    ticket = bf.place(...)
+# daemon is stopped on exit
+```
+
+---
+
+### Exceptions
+
+| Exception                 | When                                          |
+| ------------------------- | --------------------------------------------- |
+| `BinaryNotFound`          | binary not found, call `install()` first      |
+| `DaemonNotRunning`        | daemon socket not found or unreachable        |
+| `DaemonStartTimeout`      | `start()` timed out waiting for daemon        |
+| `RpcError(code, message)` | daemon returned a JSON-RPC error              |
+| `TicketNotFound`          | `cancel()` called with non-existent ticket_id |
+| `CredentialsError`        | invalid exchange name in `set_credentials()`  |
+| `InstallError`            | binary download failed                        |
+
+---
+
+## Patterns
+
+### Strategy system integration
+
+```python
+from blockfill import Blockfill, DaemonNotRunning
+
+bf = Blockfill(binary_path="/path/to/blockfill")
+
+# On startup
+if not bf.is_running():
+    bf.start(env={"BLOCKFILL_API_KEY": "..."})
+bf.health()
+
+# On each signal
+ticket = bf.place(
+    exchange="binance-futures",
+    symbol=symbol,
+    strategy="maker_l2",
+    target_position=position,
+    time_constraint_ms=300_000,
+)
+```
+
+### Idempotent placement (safe to retry)
+
+```python
+import uuid
+
+key = str(uuid.uuid4())  # generate once, reuse on retry
+
+ticket = bf.place(
+    exchange="binance-futures",
+    symbol="btcusdt",
+    strategy="maker_l2",
+    target_position=0.1,
+    time_constraint_ms=300_000,
+    client_ticket_id=key,
+)
+```
+
+### Check open positions
+
+```python
+open_tickets = bf.query(status="NEW") + bf.query(status="OPEN")
+for t in open_tickets:
+    print(t.symbol, t.target_position, t.executed_position)
+```
+
+---
+
+## AI Agent Usage
+
+The SDK is designed for programmatic use by AI agents (Claude, GPT, etc.).
+
+```python
+import sys
+sys.path.insert(0, "/path/to/python-sdk")
+
+import os
+os.environ["BLOCKFILL_API_KEY"] = "your_api_key"
+
+from blockfill import Blockfill, DaemonNotRunning, TicketNotFound
+
+bf = Blockfill(
+    binary_path="/path/to/blockfill",
+    data_dir="/path/to/data_dir",
+)
+
+if not bf.is_running():
+    bf.start(env={"BLOCKFILL_API_KEY": os.environ["BLOCKFILL_API_KEY"]})
+
+bf.health()  # raises if daemon not ready
+```
+
+Key points for agents:
+
+- Always call `bf.health()` before placing tickets
+- Use `client_ticket_id=uuid.uuid4()` for idempotent retries
+- `place()` auto-cancels existing NEW tickets for the same exchange+symbol
+- `query()` returns data from qtex MongoDB (not exchange realtime)
+
+---
+
+## Directory Structure
+
+```
+~/.blockfill/
+├── config.toml              # credentials + qtex endpoint (chmod 0600)
+├── bin/
+│   └── blockfill            # binary
+├── runtime/
+│   ├── daemon.sock          # UDS socket (CLI ↔ daemon IPC)
+│   ├── daemon.pid           # PID file
+│   └── daemon.log           # daemon logs
+└── trading-log/             # Channel B upload retry buffer
+```
+
+## Supported Exchanges
+
+| Exchange        | Value               |
+| --------------- | ------------------- |
+| Binance Futures | `"binance-futures"` |
+| OKX Swap        | `"okx-swap"`        |

blockfill-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+blockfill/__init__.py,sha256=SRnwufNFyG0daHJUsJB4iZ3JlUazNSKb3T36XWj0YrY,459
+blockfill/client.py,sha256=-88AvxXfHAVIrn2xRqj3-swaNFypaajD2kCDzW4MPBA,7416
+blockfill/config.py,sha256=dOvarHB3_hTh64wQ7c6U2TCmQkpZdSgZHSkzWITwW9U,1347
+blockfill/daemon.py,sha256=fXMbfeJOI2K0g1--tzRaeYExWCez8nPnLUr6atlvBcY,2418
+blockfill/exceptions.py,sha256=5s9-vQ2qh8-YFfIAuLuHyrh_UdxJSemJ2dNt7dVnTxQ,467
+blockfill/installer.py,sha256=SkUgd_kNIRnlALUECJp_O2yGoad52eEMB_eO2pMmLtw,1377
+blockfill/models.py,sha256=JMp0-8JZM5-06HViYX9MKpQhQqWaAySdz8P2Xl3Itvc,971
+blockfill/rpc.py,sha256=9tAyg3F8fTas5DaM12ML0HEoIhP9UEmnYLrZiZv3Src,781
+blockfill-0.1.0.dist-info/METADATA,sha256=nW7skiyIVa-cvb3Uvuzh4TGAmynP7ROKG8ANN_-BfBw,7503
+blockfill-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+blockfill-0.1.0.dist-info/top_level.txt,sha256=vGuWqvvXlW6NdWV0A4YoA5pbLXbUdD-m1QX5hZxgk3M,10
+blockfill-0.1.0.dist-info/RECORD,,

blockfill-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

blockfill-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+blockfill