exfer 0.10.0__tar.gz

exfer-0.10.0/.gitignore

@@ -0,0 +1,44 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# venvs
+.venv/
+venv/
+env/
+
+# tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.tox/
+.hypothesis/
+
+# editor
+.vscode/
+.idea/
+*.swp
+
+# mdbook generated output
+docs/book/
+
+.claude/

exfer-0.10.0/CHANGELOG.md

@@ -0,0 +1,246 @@
+# Changelog
+
+## 0.10.0 — 2026-06-10
+
+### Renamed — PyPI package `exfer-walletd` → `exfer`
+
+The old distribution name collided with the Rust daemon: `pip install
+exfer-walletd` looked like it installed the daemon, not this client.
+Install and import change accordingly:
+
+```bash
+pip install exfer
+```
+
+```python
+from exfer import Client, AsyncClient
+```
+
+No API changes — `0.10.0` is identical in surface to `exfer-walletd
+0.9.0`. The old `exfer-walletd` package on PyPI is discontinued; switch
+to `exfer`.
+
+## 0.9.0 — 2026-06-09
+
+### Breaking — address methods now return full records
+
+- `generate_address()` now returns a `GenerateAddressResult`
+  (`{"address", "pubkey", "index"}`) instead of a bare `str`. The
+  `pubkey` was previously dropped on the floor; it is the value to pass
+  as `payee_pubkey` to `quote_issue`, so callers no longer have to abuse
+  `sign_message` to recover it. Migrate `addr = c.generate_address()` →
+  `addr = c.generate_address()["address"]`.
+- `list_addresses()` now returns `list[AddressRecord]`
+  (`{"address", "index"?, "label"?, "imported"?}`) instead of
+  `list[str]`, preserving the keystore index and label/imported flag.
+  Migrate `for a in c.list_addresses()` →
+  `for rec in c.list_addresses(): a = rec["address"]`.
+
+New `TypedDict`s `GenerateAddressResult` and `AddressRecord` in
+`exfer_walletd.types`. Mirrored on both `Client` and `AsyncClient`.
+
+### New methods
+
+- `get_output_datum()` and `find_settlements_by_quote_id()` — the
+  EXFER-QUOTE settlement read surface (indexer-delegated on walletd).
+- `simulate_transfer()` gained an optional `datum` argument, so a
+  settlement dry-run reflects the on-chain size of the datum it carries.
+
+### Fixes
+
+- `transfer()` now sends the `outputs` array walletd expects; the old
+  flat `to`/`amount` shape was rejected by walletd.
+- `wait_for_tx()` / `wait_for_payment()` extend the HTTP read timeout past
+  the server-side wait, so a long confirmation wait no longer surfaces as a
+  spurious "walletd unreachable" transport error.
+
+## 0.8.0 — walletd v1.9 + v1.9.1 surface
+
+Adds the seventeen JSON-RPC methods walletd grew over its v1.7 → v1.9.1
+series. Purely additive — every method that worked in 0.7.0 still
+returns the same shape, with the same default behaviour, against the
+same default port.
+
+### New methods (mirrored on `Client` + `AsyncClient`)
+
+**HTLC spend trio (walletd v1.7+):**
+
+- `htlc_lock(*, from_, receiver, hash_lock, timeout, amount, fee=, fee_rate=, max_fee=)`
+- `htlc_claim(*, from_, lock_tx_id, preimage, sender, timeout, output_index=0, fee=)`
+- `htlc_reclaim(*, from_, lock_tx_id, receiver, hash_lock, timeout, output_index=0, fee=)`
+
+**Dry-run simulation (v1.9):**
+
+- `simulate_transfer(*, from_, outputs, fee=, fee_rate=, max_fee=)`
+- `simulate_htlc_lock(*, from_, receiver, hash_lock, timeout, amount, fee=, fee_rate=, max_fee=)`
+
+Both methods compute the exact `(size, fee, fee_rate, ...)` a real call
+would produce. No broadcast, no UTXO reservation. Lets an agent prove a
+cost ceiling before committing to spend.
+
+**Payment URI codec (v1.9, pure):**
+
+- `payment_uri_encode(*, address, amount=, memo=, hash_lock=, timeout=, label=)`
+- `payment_uri_decode(uri)`
+
+BIP21-style `exfer:<address>?amount=...&memo=...` round trip.
+
+**HTLC observability (v1.9, walletd's own index):**
+
+- `htlc_status(lock_tx_id, output_index=0)`
+- `htlc_list(*, role=, state=, since_height=, address=, limit=, cursor=)`
+- `htlc_forget(lock_tx_id, output_index=0)`
+- `get_follower_status()`
+- `wait_for_tx(tx_id, *, min_confirmations=1, timeout_secs=60)`
+
+`htlc_list` accepts either a single `HtlcState` or a list (untagged on
+the wire, walletd handles both).
+
+**Indexer-delegated (v1.9.1, multi-tenant queries):**
+
+- `list_settlements(address, *, contract_hash=, since_height=, limit=, cursor=)`
+- `contract_stats(address, *, contract_hash=)`
+- `get_address_history(address, *, since_height=, limit=, cursor=)`
+- `htlc_lookup_by_hashlock(hash_lock)`
+- `get_output_spent_by(tx_id, output_index)`
+
+These five methods need walletd to be running with `--indexer-rpc`
+pointing at an `exfer-indexer` instance. When the flag isn't set the
+SDK raises the new `IndexerNotConfiguredError`.
+
+### New result shapes in `exfer_walletd.types`
+
+`HtlcRecord` / `HtlcParams` / `HtlcClaimRecord` / `HtlcReclaimRecord` /
+`HtlcState` (Literal) / `HtlcRole` (Literal) / `HtlcLockResult` /
+`HtlcClaimResult` / `HtlcReclaimResult` / `SimulateTransferResult` /
+`SimulateHtlcLockResult` / `FollowerStatus` / `WaitForTxResult` /
+`PaymentUri` / `SettlementRecord` / `ListSettlementsResult` /
+`ContractStatsRow` / `AddressHistoryRow` / `AddressHistoryResult` /
+`HtlcListResult` / `SpentByResult`.
+
+### New errors
+
+- `WaitTimeoutError` (-32040) — `wait_for_tx` didn't see the depth in
+  time. Not terminal; the tx may still confirm.
+- `IndexerNotConfiguredError` (-32041) — caller hit an indexer-delegated
+  method on a walletd without `--indexer-rpc` configured.
+
+### Compatibility
+
+- Default URL / port unchanged (`http://127.0.0.1:7448`).
+- All pre-existing methods preserve their signatures + return types.
+- No new required runtime dependencies (`httpx` only, same as 0.7.0).
+
+## 0.7.0 — **breaking default**
+
+- `Client.from_datadir()` / `AsyncClient.from_datadir()` default URL
+  port flipped from `:8080` to `:7448`, matching walletd v0.7.0's new
+  default `--bind`. If you set `--bind` on the walletd side, this is a
+  no-op. If you relied on `:8080` defaults end-to-end, restart walletd
+  with `--bind :8080` (or update your config to `:7448`).
+- All examples in README + docs use `:7448`.
+
+## 0.6.0
+
+- **TLS pinning** for walletd's new `--tls` mode (walletd v0.5.0+).
+  Construct with `Client(url="https://…", token="…",
+  fingerprint="sha256:…")` and the SDK installs a custom transport that
+  verifies the server's leaf cert by SHA-256 instead of CA chain.
+  Mismatches raise `FingerprintMismatchError` (a `TransportError`
+  subclass).
+- `from_env()` gained `fingerprint_env="WALLETD_FINGERPRINT"` —
+  optional; only used when set.
+- `from_datadir()` auto-reads `<datadir>/cert.fingerprint` whenever
+  `url` starts with `https://`. Plain http URLs ignore it entirely.
+- `fingerprint=` and `transport=` are mutually exclusive (passing both
+  raises `ValueError`); passing `fingerprint=` with an `http://` URL
+  also raises (almost always a bug).
+- Public re-exports: `FingerprintMismatchError`.
+
+## 0.5.0 — **breaking**
+
+API polish based on dogfooding. None of the bytes-on-the-wire changed;
+this is purely SDK shape.
+
+### Breaking changes
+
+- **Single-value methods now return bare values**, not dicts:
+  - `generate_address() -> str` (was `{"address": ..., "pubkey": ...}`;
+    pubkey is dropped — open an issue if you need it back)
+  - `get_balance(addr) -> int` (was `{"address": ..., "balance": ...}`)
+  - `get_block_height() -> int` (was `{"height": ..., "block_id": ...}`)
+  - `send_raw_transaction(tx_hex) -> str` (was `{"tx_id": ...}`)
+- **`get_block(*, height|hash)` split into two methods**:
+  - `get_block_by_height(height: int) -> Block`
+  - `get_block_by_hash(block_hash: str) -> Block`
+  - The keyword-variant raised `TypeError` at runtime when called wrong;
+    splitting kills the runtime check and gives IDEs full signal.
+- **`get_transaction(tx_id=...)`** — parameter renamed from `hash` (the
+  builtin) to `tx_id` (the semantic name). Wire field stays `hash`.
+- **`ping() -> None`** (was `{"ok": True}`). Success = "didn't raise".
+- **`WalletdError.__str__`** now includes the code:
+  `"[-32020] upstream node unreachable"`. `e.code` and `e.message`
+  still exist as attributes.
+
+### Additions
+
+- **`ExferError`** — common ancestor of `WalletdError` and
+  `TransportError`. Lets you `except ExferError` as a blanket SDK
+  catch (the two operational branches stay distinct underneath).
+- **`get_tip() -> Tip`** — `NamedTuple(height: int, block_id: str)`
+  for the case where you want both pieces of the chain tip. Use
+  `get_block_height()` when you only need the int.
+- **`InsufficientBalanceError.in_flight_reserved`** now prefers the
+  error envelope's `data` field over message-scraping, with the
+  message-scrape as a fallback. Forward-compatible with a planned
+  walletd change to surface this structurally.
+
+### Internal
+
+- `TypedDict`s no longer re-exported from `exfer_walletd` top-level —
+  import from `exfer_walletd.types` if you want them. `Tip` stays
+  top-level because it's the actual return type of a method.
+- `User-Agent` version no longer late-imported inside a helper
+  function.
+
+## 0.4.0
+
+- mdBook docs site (`docs/`) deployed to GitHub Pages on every push to
+  main. Covers intro, install, quick-start, async usage, full API
+  reference, errors table, and FAQ. Local preview: `mdbook serve docs`.
+
+## 0.3.0
+
+- `tests/integration/` spawns a real `exfer-walletd` binary in a temp
+  datadir with `--node-rpc` pointed at a closed port. Round-trips
+  `healthz`, `ping`, `generate_address`, `list_addresses`, plus auth
+  and upstream-error rejection. Skipped automatically if the binary
+  isn't built (`cargo build --release` in `../exfer-walletd`) or
+  `WALLETD_BINARY` env var isn't set.
+- New CI job `integration` checks out `exfer-stack/exfer-walletd@v0.4.3`,
+  builds it, and runs the integration suite on `main` pushes.
+- `InsufficientBalanceError.in_flight_reserved` now has a regression
+  test that reconstructs walletd's exact format string from
+  `src/error.rs::insufficient_balance_message` byte-for-byte — if
+  walletd ever rewords the message, the test catches it before users
+  hit a silently-wrong `False`.
+
+## 0.2.0
+
+- `AsyncClient` mirrors every method on `Client`, on top of
+  `httpx.AsyncClient`. Sync and async share `_transport.py` so they
+  can't drift on the wire.
+
+## 0.1.0
+
+Initial release.
+
+- Sync `Client` covering every `exfer-walletd` JSON-RPC method:
+  `ping`, `generate_address`, `list_addresses`, `get_balance`,
+  `get_address_utxos`, `get_script_utxos`, `get_block_height`,
+  `get_block`, `get_transaction`, `transfer`, `send_raw_transaction`.
+- Unauthenticated `healthz()` for liveness probes.
+- Typed exception hierarchy mapped 1:1 to walletd's documented
+  JSON-RPC error codes.
+- `TypedDict` return shapes for every result — zero runtime cost,
+  full mypy/pyright coverage.

exfer-0.10.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Exfer community contributors
+
+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.

exfer-0.10.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: exfer
+Version: 0.10.0
+Summary: Typed Python client for the exfer-walletd JSON-RPC API
+Project-URL: Homepage, https://github.com/exfer-stack/exfer-py
+Project-URL: Repository, https://github.com/exfer-stack/exfer-py
+Project-URL: Bug Tracker, https://github.com/exfer-stack/exfer-py/issues
+Project-URL: exfer-walletd (Rust daemon), https://github.com/exfer-stack/exfer-walletd
+Author: exfer-stack
+License: MIT
+License-File: LICENSE
+Keywords: crypto,exfer,json-rpc,wallet,walletd
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.9
+Requires-Dist: httpx<1.0,>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy<2.0,>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# exfer (Python SDK)
+
+Typed Python client for the [`exfer-walletd`](https://github.com/exfer-stack/exfer-walletd)
+JSON-RPC API.
+
+```bash
+pip install exfer
+```
+
+```python
+from exfer import Client
+
+with Client("http://127.0.0.1:7448", token="...") as c:
+    assert c.healthz()                # True
+    res  = c.generate_address()       # {address, pubkey, index}
+    addr = res["address"]
+    bal  = c.get_balance(addr)        # int (exfers)
+
+    tx = c.transfer(
+        from_="<your-managed-address>",
+        to="<recipient-address>",
+        amount=30_000_000,            # exfers; 1 EXFER = 100_000_000 exfers
+    )
+    print(tx["tx_id"])
+```
+
+## What this is
+
+- A thin, typed wrapper over walletd's JSON-RPC. One method per RPC method.
+- Both sync (`Client`) and async (`AsyncClient`) — same surface, shared
+  wire layer so they can't drift.
+- Single-value endpoints return bare `str` / `int`. Multi-field
+  endpoints return `TypedDict`s. No `pydantic` dependency.
+
+## Async
+
+```python
+from exfer import AsyncClient
+
+async with AsyncClient("http://127.0.0.1:7448", token) as c:
+    assert await c.healthz()
+    res  = await c.generate_address()  # {address, pubkey, index}
+    print(await c.get_balance(res["address"]))
+```
+
+## What this isn't
+
+- **Not a chain client.** This SDK talks to walletd, which talks to a
+  node. It never holds keys, never signs transactions, never derives
+  addresses. If you want client-side signing, run walletd.
+- Not a high-level wallet abstraction. Methods map 1:1 to the wire
+  grammar; build helpers on top as your application needs them.
+
+## Token discovery
+
+```python
+# 1. Explicit
+Client("http://127.0.0.1:7448", "your-token")
+
+# 2. From env vars (deployed backends): WALLETD_URL + WALLETD_AUTH_TOKEN
+Client.from_env()
+
+# 3. From a local walletd datadir (dev / colocated)
+Client.from_datadir()      # reads ~/.exfer-walletd/token
+```
+
+If walletd is configured with split scopes
+(`WALLETD_AUTH_TOKEN_READ` + `WALLETD_AUTH_TOKEN_SPEND`), construct one
+`Client` per scope. A read-only token calling `transfer` raises
+`AuthenticationError`.
+
+## Errors
+
+Every documented walletd error code maps to a typed exception, all
+rooted at `ExferError`:
+
+```python
+from exfer import (
+    ExferError,               # blanket catch
+    AuthenticationError,      # -32001
+    WalletNotFoundError,      # -32010
+    UpstreamError,            # -32020 — walletd's upstream node is unreachable
+    TxAuthError,              # -32030 — UTXO authentication failed
+    InsufficientBalanceError, # -32031 — wallet can't cover amount+fee
+    InvalidParamsError,       # -32602
+    TransportError,           # walletd itself unreachable / non-JSON body
+)
+```
+
+`str(e)` is the `[-32xxx] message` form, so plain
+`log.error(f"{e}")` is enough for production.
+
+`InsufficientBalanceError.in_flight_reserved` is `True` when the
+shortfall comes from UTXOs reserved by other pending transfers from the
+same walletd — retry after they confirm.
+
+## TLS
+
+When walletd is started with `--tls` (v0.5.0+), point the SDK at the
+`https://` URL and supply the fingerprint walletd printed on first
+run:
+
+```python
+with Client.from_datadir(url="https://<walletd-host>:7448") as c:
+    c.ping()          # auto-reads cert.fingerprint alongside token
+```
+
+The SDK pins the leaf cert by SHA-256, bypassing the CA chain
+entirely. Mismatches raise `FingerprintMismatchError`.
+
+## Docs
+
+Full docs site: **<https://exfer-stack.github.io/exfer-py/>**.
+
+## Capabilities
+
+One typed method per walletd RPC, covering: addresses, balances, blocks,
+and transactions; `transfer` plus dry-run `simulate_transfer` /
+`simulate_htlc_lock`; the HTLC spend trio
+(`htlc_lock` / `htlc_claim` / `htlc_reclaim`) and HTLC observability
+(`htlc_status` / `htlc_list` / `htlc_forget` / `htlc_lookup_by_hashlock`);
+BIP21-style payment URIs (`payment_uri_encode` / `payment_uri_decode`);
+EXFER-QUOTE signed price credentials (`quote_issue` / `quote_verify`);
+message signing (`sign_message` / `verify_message`); indexer-delegated
+queries (`list_settlements`, `contract_stats`, `get_address_history`,
+`get_attestation_edges`, `get_output_spent_by`, `get_output_datum`,
+`find_settlements_by_quote_id`, `detect_in_chain_swaps`); and
+observability (`wait_for_tx`, `wait_for_payment`, `get_follower_status`).
+
+## Status
+
+`0.10.0` — alpha. Tested against `exfer-walletd >= 1.9.1` (HTLC,
+dry-run simulation, payment URIs, quotes, message signing, and
+indexer-delegated queries). TLS pinning supported since `0.6.0`.
+
+MIT licensed.

exfer-0.10.0/README.md

@@ -0,0 +1,136 @@
+# exfer (Python SDK)
+
+Typed Python client for the [`exfer-walletd`](https://github.com/exfer-stack/exfer-walletd)
+JSON-RPC API.
+
+```bash
+pip install exfer
+```
+
+```python
+from exfer import Client
+
+with Client("http://127.0.0.1:7448", token="...") as c:
+    assert c.healthz()                # True
+    res  = c.generate_address()       # {address, pubkey, index}
+    addr = res["address"]
+    bal  = c.get_balance(addr)        # int (exfers)
+
+    tx = c.transfer(
+        from_="<your-managed-address>",
+        to="<recipient-address>",
+        amount=30_000_000,            # exfers; 1 EXFER = 100_000_000 exfers
+    )
+    print(tx["tx_id"])
+```
+
+## What this is
+
+- A thin, typed wrapper over walletd's JSON-RPC. One method per RPC method.
+- Both sync (`Client`) and async (`AsyncClient`) — same surface, shared
+  wire layer so they can't drift.
+- Single-value endpoints return bare `str` / `int`. Multi-field
+  endpoints return `TypedDict`s. No `pydantic` dependency.
+
+## Async
+
+```python
+from exfer import AsyncClient
+
+async with AsyncClient("http://127.0.0.1:7448", token) as c:
+    assert await c.healthz()
+    res  = await c.generate_address()  # {address, pubkey, index}
+    print(await c.get_balance(res["address"]))
+```
+
+## What this isn't
+
+- **Not a chain client.** This SDK talks to walletd, which talks to a
+  node. It never holds keys, never signs transactions, never derives
+  addresses. If you want client-side signing, run walletd.
+- Not a high-level wallet abstraction. Methods map 1:1 to the wire
+  grammar; build helpers on top as your application needs them.
+
+## Token discovery
+
+```python
+# 1. Explicit
+Client("http://127.0.0.1:7448", "your-token")
+
+# 2. From env vars (deployed backends): WALLETD_URL + WALLETD_AUTH_TOKEN
+Client.from_env()
+
+# 3. From a local walletd datadir (dev / colocated)
+Client.from_datadir()      # reads ~/.exfer-walletd/token
+```
+
+If walletd is configured with split scopes
+(`WALLETD_AUTH_TOKEN_READ` + `WALLETD_AUTH_TOKEN_SPEND`), construct one
+`Client` per scope. A read-only token calling `transfer` raises
+`AuthenticationError`.
+
+## Errors
+
+Every documented walletd error code maps to a typed exception, all
+rooted at `ExferError`:
+
+```python
+from exfer import (
+    ExferError,               # blanket catch
+    AuthenticationError,      # -32001
+    WalletNotFoundError,      # -32010
+    UpstreamError,            # -32020 — walletd's upstream node is unreachable
+    TxAuthError,              # -32030 — UTXO authentication failed
+    InsufficientBalanceError, # -32031 — wallet can't cover amount+fee
+    InvalidParamsError,       # -32602
+    TransportError,           # walletd itself unreachable / non-JSON body
+)
+```
+
+`str(e)` is the `[-32xxx] message` form, so plain
+`log.error(f"{e}")` is enough for production.
+
+`InsufficientBalanceError.in_flight_reserved` is `True` when the
+shortfall comes from UTXOs reserved by other pending transfers from the
+same walletd — retry after they confirm.
+
+## TLS
+
+When walletd is started with `--tls` (v0.5.0+), point the SDK at the
+`https://` URL and supply the fingerprint walletd printed on first
+run:
+
+```python
+with Client.from_datadir(url="https://<walletd-host>:7448") as c:
+    c.ping()          # auto-reads cert.fingerprint alongside token
+```
+
+The SDK pins the leaf cert by SHA-256, bypassing the CA chain
+entirely. Mismatches raise `FingerprintMismatchError`.
+
+## Docs
+
+Full docs site: **<https://exfer-stack.github.io/exfer-py/>**.
+
+## Capabilities
+
+One typed method per walletd RPC, covering: addresses, balances, blocks,
+and transactions; `transfer` plus dry-run `simulate_transfer` /
+`simulate_htlc_lock`; the HTLC spend trio
+(`htlc_lock` / `htlc_claim` / `htlc_reclaim`) and HTLC observability
+(`htlc_status` / `htlc_list` / `htlc_forget` / `htlc_lookup_by_hashlock`);
+BIP21-style payment URIs (`payment_uri_encode` / `payment_uri_decode`);
+EXFER-QUOTE signed price credentials (`quote_issue` / `quote_verify`);
+message signing (`sign_message` / `verify_message`); indexer-delegated
+queries (`list_settlements`, `contract_stats`, `get_address_history`,
+`get_attestation_edges`, `get_output_spent_by`, `get_output_datum`,
+`find_settlements_by_quote_id`, `detect_in_chain_swaps`); and
+observability (`wait_for_tx`, `wait_for_payment`, `get_follower_status`).
+
+## Status
+
+`0.10.0` — alpha. Tested against `exfer-walletd >= 1.9.1` (HTLC,
+dry-run simulation, payment URIs, quotes, message signing, and
+indexer-delegated queries). TLS pinning supported since `0.6.0`.
+
+MIT licensed.