k402 0.1.0__tar.gz

k402-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+*.db

k402-0.1.0/LICENSE

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

k402-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: k402
+Version: 0.1.0
+Summary: k402 — HTTP 402 payments on Kaspa. Protocol library: client, server middleware, and PNN-backed verification. No accounts, no API keys.
+Project-URL: Homepage, https://github.com/Kali123411/k402
+Project-URL: Repository, https://github.com/Kali123411/k402
+Author: Kaspa Lab
+License: MIT
+License-File: LICENSE
+Keywords: agent-payments,http-402,k402,kaspa,micropayments,payments,x402
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: all
+Requires-Dist: fastapi>=0.110; extra == 'all'
+Requires-Dist: kaspa>=2.0; extra == 'all'
+Provides-Extra: kaspa
+Requires-Dist: kaspa>=2.0; extra == 'kaspa'
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110; extra == 'server'
+Description-Content-Type: text/markdown
+
+# k402
+
+**HTTP 402 payments on Kaspa.** Charge (or pay) KAS per API call — no
+accounts, no API keys, no card rails. Kaspa confirms in ~1 second, so a
+non-custodial payment adds about a second to the first request and nothing
+after that.
+
+The wire protocol is [PROTOCOL.md](PROTOCOL.md) — one 402 body, one header,
+implementable in any language. This package is the Python reference
+implementation: client, FastAPI server middleware, and chain verification.
+
+```
+pip install 'k402[all]'     # client + server + kaspa SDK
+pip install k402            # protocol types + client only (httpx)
+```
+
+## Sell: gate a FastAPI endpoint
+
+```python
+from fastapi import FastAPI, Depends
+from k402 import K402, XpubAddressProvider, PnnBackend, SqliteStore
+
+k402 = K402(
+    address_provider=XpubAddressProvider("kpub..."),   # watch-only: server holds no keys
+    backend=PnnBackend(),          # dev/test: community Public Node Network
+                                   # prod: NodeBackend("ws://your-node:17110")
+    store=SqliteStore("payments.db"),
+)
+
+app = FastAPI()
+k402.install(app)
+
+@app.post("/summarize")
+async def summarize(body: dict, payment=Depends(k402.paid(sompi=1_500_000))):
+    return {"summary": ..., "paid_by_tx": payment.meta["txid"]}
+```
+
+Unpaid calls get a protocol 402 with a fresh payment address; paid calls run.
+Replay, expiry, and double-spend-of-the-quote are handled for you.
+
+## Buy: a client that pays as it goes
+
+```python
+from k402 import Client, HotWallet
+
+client = Client(payer=HotWallet(private_key_hex), max_kas_per_call=0.1)
+r = await client.post("https://api.example.com/summarize", json={"text": ...})
+```
+
+The client hits the endpoint, gets the 402, pays the exact quoted sompi from
+its wallet, retries with proof, and returns the real response. The
+`max_kas_per_call` guard caps what it will ever pay (facilitator fees
+included) without asking you.
+
+No wallet? Services may also offer `kaspa-session` (prepaid balance):
+`Client(session="s_...")`.
+
+## Chain backends
+
+| Backend | Use | Notes |
+|---|---|---|
+| `PnnBackend()` | development, testing | resolves a community [PNN](https://kaspa.aspectron.org/rpc/pnn.html) node via the Kaspa Resolver; dev/test-grade by PNN's own guidance |
+| `NodeBackend("ws://host:17110")` | production | your own node (`kaspad --utxoindex`), wRPC Borsh endpoint |
+
+## Design in one paragraph
+
+Every payment gets a **fresh watch-only address**, so verification is just
+"has this address received N sompi" — answerable by any UTXO-indexed node, no
+tx parsing, no payloads, no custody anywhere. Payment ids are single-use and
+marked atomically (replay protection). The protocol takes **no fee**; services
+built on it (facilitators, hosted checkout) quote theirs as a transparent
+`facilitator_fee` line item. Amounts are integer sompi strings end-to-end.
+
+## Status
+
+v0.1.0 — wire protocol stable enough to build against; API may move.
+MIT license.

k402-0.1.0/PROTOCOL.md

@@ -0,0 +1,134 @@
+# k402 protocol — v0.1
+
+**HTTP 402 payments on Kaspa.** An open convention any HTTP service can
+implement to charge KAS per call — no accounts, no API keys, no card rails.
+What [x402](https://www.x402.org/) is for EVM stablecoin payments, k402 is for
+Kaspa, whose ~1-second confirmations at 10 blocks/sec make direct, per-call,
+non-custodial payment practical without channels or invoices.
+
+This document is the protocol. It is intentionally small: one response body,
+one request header, and per-scheme verification rules. Anything not specified
+here (pricing, discovery, catalogs, dashboards) is a service concern, not a
+protocol concern.
+
+## 1. Flow
+
+1. Client calls a paid endpoint with no payment attached.
+2. Server responds `402 Payment Required` with an **offer body** (§2).
+3. Client satisfies one offered scheme (§4) and retries the request with a
+   **payment header** (§3) — or, for `kaspa-session`, an `X-Session` header.
+4. Server verifies (§5) and serves the request.
+
+## 2. The 402 offer body
+
+```json
+{
+  "k402": "0.1",
+  "accepts": [
+    {
+      "scheme": "kaspa-utxo",
+      "network": "mainnet",
+      "amount_sompi": "1500000",
+      "pay_to": "kaspa:qr...",
+      "payment_id": "p_8f3ab2c4...",
+      "expires": 1784074500,
+      "description": "summarize, ~150 words",
+      "finality": 1,
+      "facilitator_fee": { "sompi": "2000", "to": "kaspa:qq...", "by": "example.dev" }
+    },
+    { "scheme": "kaspa-session", "open": "/onboard/request" }
+  ],
+  "reason": "optional human-readable string when re-402ing a failed payment"
+}
+```
+
+Rules:
+
+- `k402` (required): protocol version. This document defines `"0.1"`.
+- `accepts` (required): one entry per acceptable scheme. Clients MUST ignore
+  entries whose `scheme` they do not recognize.
+- All amounts are **sompi, as strings of integers**. Float KAS never crosses
+  the wire. (1 KAS = 100,000,000 sompi.)
+- `pay_to` MUST be a **fresh address per payment_id** (see §5 for why).
+- `expires` (unix seconds): after this the server MAY refuse the quote and
+  MUST respond with a fresh 402 offer.
+- `finality` (optional, default 1): DAA-score depth the server requires before
+  serving. 1 means "accepted" (~1 s on mainnet).
+- `facilitator_fee` (optional): a transparent service fee the payer adds as a
+  second output. See §6.
+- `description`, `reason` (optional): human/agent-readable strings.
+
+## 3. The payment header
+
+```
+X-K402-Payment: kaspa-utxo <txid> <payment_id>
+```
+
+Three space-separated tokens: scheme, the id of the paying transaction, and
+the `payment_id` from the offer being satisfied.
+
+## 4. Schemes
+
+### `kaspa-utxo` — non-custodial per-call payment
+
+The client sends `amount_sompi` to `pay_to` on `network`, plus
+`facilitator_fee.sompi` to `facilitator_fee.to` if present, then retries with
+the payment header. Overpayment is the server's to keep; underpayment fails
+verification.
+
+### `kaspa-session` — prepaid metered balance
+
+The offer's `open` field is a URL (absolute or relative to the service) that
+mints `{"session": "...", "depositAddress": "kaspa:..."}`. The client funds
+the deposit address; confirmed deposits become spendable balance; subsequent
+requests carry `X-Session: <session>` and the server meters against the
+balance. Zero added latency per call; the merchant holds the float. Session
+lifecycle beyond `open` is service-defined.
+
+### `kaspa-channel` — reserved
+
+Covenant-based unidirectional payment channels (per-call granularity with
+zero per-call chain latency). Reserved for a future protocol version.
+
+## 5. Verification (`kaspa-utxo`)
+
+On receiving the payment header the server:
+
+1. Looks up `payment_id`. Unknown, already-used, or expired → fresh 402.
+2. Checks the chain: total sompi received by `pay_to` ≥ `amount_sompi`, at the
+   offer's `finality` depth. Because `pay_to` is fresh per payment, "balance of
+   the address" is the whole check — any node with a UTXO index can answer it,
+   and no transaction parsing or payload inspection is required.
+3. Atomically marks `payment_id` used (replay protection), then serves.
+
+A payment that has not yet landed is a normal race at 1-second block times:
+servers SHOULD answer with a 402 whose `reason` says so, and clients SHOULD
+retry for a few seconds before treating payment as failed.
+
+## 6. Fees
+
+**The protocol itself extracts no fee.** There is no protocol-level fee
+output, no routed settlement, no percentage. Payments go client → merchant.
+
+Services layered on the rail (facilitators, hosted checkouts, channel
+operators) MAY charge for their work by quoting `facilitator_fee` in offers
+they produce. The fee is a visible line item the client pays as an explicit
+extra output — never hidden in `amount_sompi`. Clients MUST count it toward
+any per-call spending guard they enforce.
+
+## 7. Security notes
+
+- **Merchants:** derive `pay_to` watch-only (xpub) — the web server should
+  never hold spending keys. Persist payment_ids durably; `mark used` must be
+  atomic under concurrency.
+- **Clients:** enforce a per-call spend ceiling before paying any offer;
+  treat `expires` as hard; never pay the same offer twice.
+- **Both:** amounts are integers end-to-end. A server MUST NOT serve on a
+  partial payment; a client SHOULD overpay dust rather than round down.
+
+## 8. Reference implementation
+
+`pip install k402` — Python client (`k402.Client`), FastAPI server middleware
+(`k402.K402`), watch-only xpub derivation, and chain verification via your own
+node or the community [Public Node Network](https://kaspa.aspectron.org/rpc/pnn.html)
+(dev/test). MIT-licensed; this spec may be implemented by anyone in anything.

k402-0.1.0/README.md

@@ -0,0 +1,77 @@
+# k402
+
+**HTTP 402 payments on Kaspa.** Charge (or pay) KAS per API call — no
+accounts, no API keys, no card rails. Kaspa confirms in ~1 second, so a
+non-custodial payment adds about a second to the first request and nothing
+after that.
+
+The wire protocol is [PROTOCOL.md](PROTOCOL.md) — one 402 body, one header,
+implementable in any language. This package is the Python reference
+implementation: client, FastAPI server middleware, and chain verification.
+
+```
+pip install 'k402[all]'     # client + server + kaspa SDK
+pip install k402            # protocol types + client only (httpx)
+```
+
+## Sell: gate a FastAPI endpoint
+
+```python
+from fastapi import FastAPI, Depends
+from k402 import K402, XpubAddressProvider, PnnBackend, SqliteStore
+
+k402 = K402(
+    address_provider=XpubAddressProvider("kpub..."),   # watch-only: server holds no keys
+    backend=PnnBackend(),          # dev/test: community Public Node Network
+                                   # prod: NodeBackend("ws://your-node:17110")
+    store=SqliteStore("payments.db"),
+)
+
+app = FastAPI()
+k402.install(app)
+
+@app.post("/summarize")
+async def summarize(body: dict, payment=Depends(k402.paid(sompi=1_500_000))):
+    return {"summary": ..., "paid_by_tx": payment.meta["txid"]}
+```
+
+Unpaid calls get a protocol 402 with a fresh payment address; paid calls run.
+Replay, expiry, and double-spend-of-the-quote are handled for you.
+
+## Buy: a client that pays as it goes
+
+```python
+from k402 import Client, HotWallet
+
+client = Client(payer=HotWallet(private_key_hex), max_kas_per_call=0.1)
+r = await client.post("https://api.example.com/summarize", json={"text": ...})
+```
+
+The client hits the endpoint, gets the 402, pays the exact quoted sompi from
+its wallet, retries with proof, and returns the real response. The
+`max_kas_per_call` guard caps what it will ever pay (facilitator fees
+included) without asking you.
+
+No wallet? Services may also offer `kaspa-session` (prepaid balance):
+`Client(session="s_...")`.
+
+## Chain backends
+
+| Backend | Use | Notes |
+|---|---|---|
+| `PnnBackend()` | development, testing | resolves a community [PNN](https://kaspa.aspectron.org/rpc/pnn.html) node via the Kaspa Resolver; dev/test-grade by PNN's own guidance |
+| `NodeBackend("ws://host:17110")` | production | your own node (`kaspad --utxoindex`), wRPC Borsh endpoint |
+
+## Design in one paragraph
+
+Every payment gets a **fresh watch-only address**, so verification is just
+"has this address received N sompi" — answerable by any UTXO-indexed node, no
+tx parsing, no payloads, no custody anywhere. Payment ids are single-use and
+marked atomically (replay protection). The protocol takes **no fee**; services
+built on it (facilitators, hosted checkout) quote theirs as a transparent
+`facilitator_fee` line item. Amounts are integer sompi strings end-to-end.
+
+## Status
+
+v0.1.0 — wire protocol stable enough to build against; API may move.
+MIT license.

k402-0.1.0/k402/__init__.py

@@ -0,0 +1,32 @@
+# k402 — HTTP 402 payments on Kaspa. See PROTOCOL.md for the wire protocol.
+from .addresses import (AddressProvider, CallbackAddressProvider,
+                        StaticAddressProvider, XpubAddressProvider)
+from .backend import ChainBackend, NodeBackend, PnnBackend
+from .client import Client, Payer, PaymentFailed
+from .schemes import (K402_VERSION, PAYMENT_HEADER, SESSION_HEADER,
+                      FacilitatorFee, ProtocolError, SessionOffer, UtxoOffer,
+                      format_payment_header, parse_offers, parse_payment_header,
+                      payment_required_body)
+from .server import K402, PaymentRequired
+from .store import MemoryStore, PaymentRecord, PaymentStore, SqliteStore
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "K402", "Client", "PaymentRequired", "PaymentFailed",
+    "UtxoOffer", "SessionOffer", "FacilitatorFee", "ProtocolError",
+    "parse_offers", "payment_required_body",
+    "format_payment_header", "parse_payment_header",
+    "PAYMENT_HEADER", "SESSION_HEADER", "K402_VERSION",
+    "PnnBackend", "NodeBackend", "ChainBackend",
+    "AddressProvider", "XpubAddressProvider", "CallbackAddressProvider",
+    "StaticAddressProvider",
+    "PaymentStore", "MemoryStore", "SqliteStore", "PaymentRecord",
+    "Payer",
+]
+
+try:  # optional: requires the kaspa SDK extra
+    from .wallet import HotWallet  # noqa: F401
+    __all__.append("HotWallet")
+except ImportError:
+    pass

k402-0.1.0/k402/addresses.py

@@ -0,0 +1,59 @@
+# Address providers hand the server a fresh pay_to address per payment_id.
+# The recommended provider is watch-only xpub derivation: the web server never
+# holds a private key, so a compromised server can lose at most unswept revenue.
+from __future__ import annotations
+
+import itertools
+import threading
+from typing import Callable, Protocol
+
+
+class AddressProvider(Protocol):
+    def next_address(self, payment_id: str) -> str: ...
+
+
+class CallbackAddressProvider:
+    """Bring your own derivation: fn(payment_id) -> address."""
+
+    def __init__(self, fn: Callable[[str], str]):
+        self._fn = fn
+
+    def next_address(self, payment_id: str) -> str:
+        return self._fn(payment_id)
+
+
+class XpubAddressProvider:
+    """Watch-only HD derivation from an account xpub (kaspa SDK required).
+
+    NOTE: the index counter is in-memory. Across restarts pass start_index
+    higher than any previously issued index (persist it next to your payment
+    store) — reusing an index only risks correlating two payments to one
+    address, not losing funds, but fresh-per-payment is the protocol's intent.
+    """
+
+    def __init__(self, xpub: str, network: str = "mainnet", start_index: int = 0):
+        try:
+            from kaspa import PublicKeyGenerator
+        except ImportError as e:
+            raise ImportError(
+                "XpubAddressProvider needs the kaspa SDK: pip install 'k402[kaspa]'") from e
+        self._gen = PublicKeyGenerator.from_xpub(xpub)
+        self._network = network
+        self._counter = itertools.count(start_index)
+        self._lock = threading.Lock()
+
+    def next_address(self, payment_id: str) -> str:
+        with self._lock:
+            index = next(self._counter)
+        return self._gen.receive_address_as_string(self._network, index)
+
+
+class StaticAddressProvider:
+    """A fixed address for every payment. Dev/demo ONLY: concurrent payments to
+    one address can satisfy each other's verification. Never use in production."""
+
+    def __init__(self, address: str):
+        self._address = address
+
+    def next_address(self, payment_id: str) -> str:
+        return self._address

k402-0.1.0/k402/backend.py

@@ -0,0 +1,92 @@
+# Chain backends answer one question for the verifier: how many sompi has an
+# address received? Fresh-address-per-payment makes that equal to its balance.
+#
+# PnnBackend resolves a public node via the Kaspa Resolver (PNN,
+# https://kaspa.aspectron.org/rpc/pnn.html). PNN is dev/test-grade by its own
+# docs — point production at your own node with NodeBackend(url=...).
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Optional, Protocol
+
+
+class ChainBackend(Protocol):
+    async def address_received_sompi(self, address: str) -> int: ...
+    async def close(self) -> None: ...
+
+
+def _require_kaspa():
+    try:
+        import kaspa
+        return kaspa
+    except ImportError as e:
+        raise ImportError(
+            "chain backends need the kaspa SDK: pip install 'k402[kaspa]'") from e
+
+
+class _RpcBackend:
+    """Shared wRPC client lifecycle for resolver- and url-based backends."""
+
+    def __init__(self, network: str = "mainnet", url: Optional[str] = None):
+        self.network = network
+        self.url = url
+        self._client = None
+        self._lock = asyncio.Lock()
+
+    async def _rpc(self):
+        kaspa = _require_kaspa()
+        async with self._lock:
+            if self._client is None or not self._client.is_connected():
+                if self.url:
+                    self._client = kaspa.RpcClient(url=self.url)
+                else:
+                    self._client = kaspa.RpcClient(
+                        resolver=kaspa.Resolver(), network_id=self.network)
+                await self._client.connect()
+            return self._client
+
+    async def address_received_sompi(self, address: str) -> int:
+        rpc = await self._rpc()
+        resp = await rpc.get_balance_by_address({"address": address})
+        return int(resp["balance"])
+
+    async def utxos(self, address: str) -> list:
+        rpc = await self._rpc()
+        resp = await rpc.get_utxos_by_addresses({"addresses": [address]})
+        return resp["entries"]
+
+    async def submit_transaction(self, pending) -> str:
+        rpc = await self._rpc()
+        return await pending.submit(rpc)
+
+    async def wait_for_payment(self, address: str, amount_sompi: int,
+                               timeout: float = 120.0, poll: float = 1.0) -> bool:
+        """Poll until `address` has received `amount_sompi` (Kaspa confirms ~1s,
+        so polling at 1s is adequate; a utxos-changed subscription can replace
+        this later without changing callers)."""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if await self.address_received_sompi(address) >= amount_sompi:
+                return True
+            await asyncio.sleep(poll)
+        return False
+
+    async def close(self) -> None:
+        if self._client is not None and self._client.is_connected():
+            await self._client.disconnect()
+        self._client = None
+
+
+class PnnBackend(_RpcBackend):
+    """Public Node Network via the Kaspa Resolver. Dev/test-grade."""
+
+    def __init__(self, network: str = "mainnet"):
+        super().__init__(network=network)
+
+
+class NodeBackend(_RpcBackend):
+    """Your own node's wRPC endpoint (e.g. ws://127.0.0.1:17110). Production."""
+
+    def __init__(self, url: str, network: str = "mainnet"):
+        super().__init__(network=network, url=url)

k402-0.1.0/k402/client.py

@@ -0,0 +1,88 @@
+# Client side of k402: an httpx wrapper that turns HTTP 402 into payment.
+#
+#   client = Client(payer=HotWallet(private_key))       # kaspa-utxo, non-custodial
+#   client = Client(session="s_...")                    # kaspa-session, prepaid
+#   r = await client.post("https://api.example/summarize", json={...})
+from __future__ import annotations
+
+from typing import Optional, Protocol
+
+import httpx
+
+from .schemes import (PAYMENT_HEADER, SESSION_HEADER, ProtocolError,
+                      SessionOffer, UtxoOffer, format_payment_header,
+                      parse_offers)
+
+
+class Payer(Protocol):
+    async def pay(self, offer: UtxoOffer) -> str:
+        """Pay the offer on-chain; return the txid."""
+        ...
+
+
+class PaymentFailed(Exception):
+    """The 402 could not be satisfied. `offers` holds what the server accepts."""
+
+    def __init__(self, message: str, offers: Optional[list] = None):
+        self.offers = offers or []
+        super().__init__(message)
+
+
+class Client:
+    def __init__(self, payer: Optional[Payer] = None, session: Optional[str] = None,
+                 max_kas_per_call: float = 1.0, confirm_retries: int = 5,
+                 http: Optional[httpx.AsyncClient] = None):
+        self.payer = payer
+        self.session = session
+        self.max_sompi_per_call = int(max_kas_per_call * 100_000_000)
+        self.confirm_retries = confirm_retries
+        self.http = http or httpx.AsyncClient(timeout=180)
+
+    async def request(self, method: str, url: str, **kwargs) -> httpx.Response:
+        headers = dict(kwargs.pop("headers", {}) or {})
+        if self.session:
+            headers[SESSION_HEADER] = self.session
+
+        r = await self.http.request(method, url, headers=headers, **kwargs)
+        if r.status_code != 402:
+            return r
+
+        try:
+            offers = parse_offers(r.json())
+        except (ProtocolError, ValueError) as e:
+            raise PaymentFailed(f"server sent 402 but not a k402 body: {e}")
+
+        utxo = next((o for o in offers if isinstance(o, UtxoOffer)), None)
+        if utxo is None or self.payer is None:
+            hint = next((f"open a session at {o.open}" for o in offers
+                         if isinstance(o, SessionOffer)), "no payable offer")
+            raise PaymentFailed(
+                f"payment required and no payer configured ({hint})", offers)
+
+        if utxo.total_sompi > self.max_sompi_per_call:
+            raise PaymentFailed(
+                f"offer wants {utxo.total_sompi} sompi, over the "
+                f"max_kas_per_call guard of {self.max_sompi_per_call}", offers)
+
+        txid = await self.payer.pay(utxo)
+        headers[PAYMENT_HEADER] = format_payment_header(txid, utxo.payment_id)
+
+        # Kaspa accepts in ~1s; retry briefly in case we beat the node to it.
+        import asyncio
+        for attempt in range(self.confirm_retries):
+            r = await self.http.request(method, url, headers=headers, **kwargs)
+            if r.status_code != 402:
+                return r
+            await asyncio.sleep(1.0 + attempt)
+        raise PaymentFailed(
+            f"paid tx {txid} but server still returns 402 after "
+            f"{self.confirm_retries} retries", offers)
+
+    async def get(self, url: str, **kw) -> httpx.Response:
+        return await self.request("GET", url, **kw)
+
+    async def post(self, url: str, **kw) -> httpx.Response:
+        return await self.request("POST", url, **kw)
+
+    async def aclose(self) -> None:
+        await self.http.aclose()