solverr 0.1.0__py3-none-any.whl

solverr/types.py

@@ -0,0 +1,298 @@
+"""Shapes of the objects the Solverr API returns and the events it sends."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+# Every object an API key reaches is live; test mode exists only for demo store invoices.
+Mode = Literal["live"]
+
+Currency = Literal["USD", "EUR", "INR"]
+
+InvoiceStatus = Literal[
+    "created",
+    "awaiting_payment",
+    "detected",
+    "processing",
+    "paid",
+    "underpaid",
+    "refunded",
+    "failed",
+    "expired",
+]
+
+RefundStatus = Literal["pending", "processing", "completed", "failed", "canceled"]
+
+PayoutStatus = Literal["pending", "processing", "completed", "failed", "canceled"]
+
+SubscriptionInterval = Literal["week", "month"]
+
+SubscriptionStatus = Literal["active", "canceled"]
+
+
+class Settlement(TypedDict):
+    """The coin and amount the business receives for an invoice."""
+
+    asset_id: str
+    symbol: str
+    blockchain: str
+    amount: str
+    amount_base: str
+
+
+class Invoice(TypedDict):
+    id: str
+    object: Literal["invoice"]
+    mode: Mode
+    status: InvoiceStatus
+    amount: str
+    currency: Currency
+    order_id: str | None
+    description: str | None
+    customer_email: str | None
+    redirect_url: str | None
+    metadata: dict[str, str]
+    settlement: Settlement
+    late: bool
+    extra_payment: bool
+    checkout_url: str
+    receipt_url: str | None
+    redeemed_at: str | None
+    expires_at: str
+    created_at: str
+
+
+class PaymentCoin(TypedDict):
+    asset_id: str
+    symbol: str
+    blockchain: str
+    chain_name: str
+    decimals: int
+
+
+class PaymentTransaction(TypedDict):
+    hash: str
+    url: str | None
+
+
+class Payment(TypedDict):
+    """One payment attempt on an invoice: a quote and its latest network status."""
+
+    id: str
+    object: Literal["payment"]
+    status: str
+    coin: PaymentCoin
+    amount_in: str
+    amount_in_base: str
+    min_amount_in_base: str
+    amount_in_usd: str | None
+    deposit_address: str
+    deposit_memo: str | None
+    refund_address: str
+    # True when NEAR Intents quoted this attempt as a confidential intent (private payments).
+    confidential: bool
+    deadline: str
+    time_estimate_seconds: int
+    deposited_amount: str | None
+    refunded_amount: str | None
+    refund_fee: str | None
+    refund_reason: str | None
+    origin_transactions: list[PaymentTransaction]
+    destination_transactions: list[PaymentTransaction]
+    correlation_id: str
+    quote_signature: str
+    created_at: str
+
+
+class PaymentLink(TypedDict):
+    id: str
+    object: Literal["payment_link"]
+    mode: Mode
+    url: str
+    title: str
+    amount: str | None
+    currency: Currency
+    redirect_url: str | None
+    active: bool
+    created_at: str
+
+
+class Refund(TypedDict):
+    """``amount`` is in ``source_asset``, the business's settlement coin; the payer receives ``asset_id`` at ``recipient``."""
+
+    id: str
+    object: Literal["refund"]
+    status: RefundStatus
+    invoice_id: str
+    batch_id: str | None
+    amount: str
+    source_asset: str
+    asset_id: str
+    recipient: str
+    tx_hash: str | None
+    failure_reason: str | None
+    sign_url: str
+    created_at: str
+
+
+class Payout(TypedDict):
+    """``amount`` is in ``source_asset``, the business's settlement coin; the recipient receives ``asset_id``."""
+
+    id: str
+    object: Literal["payout"]
+    status: PayoutStatus
+    invoice_id: str | None
+    batch_id: str | None
+    amount: str
+    source_asset: str
+    asset_id: str
+    recipient: str
+    tx_hash: str | None
+    failure_reason: str | None
+    sign_url: str
+    created_at: str
+
+
+class PayoutBatch(TypedDict):
+    """``id`` is the ``batch_id`` of every payout in ``data``."""
+
+    object: Literal["payout_batch"]
+    id: str
+    data: list[Payout]
+
+
+class Subscription(TypedDict):
+    id: str
+    object: Literal["subscription"]
+    status: SubscriptionStatus
+    customer_email: str
+    amount: str
+    currency: Currency
+    interval: SubscriptionInterval
+    description: str | None
+    next_invoice_at: str
+    created_at: str
+
+
+class _CreditAccountBase(TypedDict):
+    id: str
+    object: Literal["credit_account"]
+    balance: str
+    currency: Literal["USD"]
+
+
+class CreditAccount(_CreditAccountBase, total=False):
+    # Returned only when the account is created. Store it like a password.
+    token: str
+
+
+class CreditTopup(TypedDict):
+    credit_account: CreditAccount
+    invoice: Invoice
+
+
+class _CreditChargeBase(TypedDict):
+    # Charge id (cru_…); pass it to credits.refund_charge to give the charge back.
+    id: str
+    object: Literal["credit_charge"]
+    amount: str
+    # Balance after the charge or refund, with 6 decimals.
+    balance: str
+    currency: Literal["USD"]
+
+
+class CreditCharge(_CreditChargeBase, total=False):
+    # True on the answer of credits.refund_charge.
+    refunded: bool
+
+
+class Token(TypedDict):
+    """A coin the checkout accepts; a payout's ``asset_id`` is one of these."""
+
+    asset_id: str
+    symbol: str
+    blockchain: str
+    # Display name of the chain, such as "Base".
+    chain_name: str
+    decimals: int
+    price_usd: float
+    # Token contract, or None for a chain's native coin.
+    contract_address: str | None
+
+
+class WebhookTest(TypedDict):
+    queued: Literal[True]
+
+
+class InvoiceRedemption(TypedDict):
+    id: str
+    redeemed_at: str
+    payment: Payment | None
+
+
+class InvoiceList(TypedDict):
+    object: Literal["list"]
+    data: list[Invoice]
+    has_more: bool
+
+
+class PaymentLinkList(TypedDict):
+    object: Literal["list"]
+    data: list[PaymentLink]
+    has_more: bool
+
+
+class RefundList(TypedDict):
+    object: Literal["list"]
+    data: list[Refund]
+    has_more: bool
+
+
+class PayoutList(TypedDict):
+    object: Literal["list"]
+    data: list[Payout]
+    has_more: bool
+
+
+class SubscriptionList(TypedDict):
+    object: Literal["list"]
+    data: list[Subscription]
+    has_more: bool
+
+
+class TokenList(TypedDict):
+    """Every coin at once; unlike other lists it has no pages and no ``has_more``."""
+
+    object: Literal["list"]
+    data: list[Token]
+
+
+WebhookEventType = Literal[
+    "invoice.detected",
+    "invoice.paid",
+    "invoice.underpaid",
+    "invoice.refunded",
+    "invoice.failed",
+    "invoice.expired",
+    "invoice.extra_payment",
+    "subscription.invoice_created",
+    "refund.completed",
+    "refund.failed",
+    "refund.canceled",
+    "payout.completed",
+    "payout.failed",
+    "payout.canceled",
+    "support_case.created",
+    "test.ping",
+]
+
+
+class WebhookEvent(TypedDict):
+    """A verified webhook event; by type, ``data`` holds ``invoice`` (and ``payment``), ``refund``, ``payout``,
+    ``support_case`` with ``invoice``, or ``message`` for ``test.ping``."""
+
+    id: str
+    type: WebhookEventType
+    mode: Mode
+    created_at: str
+    data: dict[str, Any]

solverr/webhooks.py

@@ -0,0 +1,109 @@
+"""Verification of the signed webhook events Solverr sends to a business's endpoint."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import hashlib
+import hmac
+import json
+import re
+import time
+from collections.abc import Iterable
+from typing import Protocol, cast
+
+from ._config import (
+    WEBHOOK_ID_HEADER,
+    WEBHOOK_SECRET_MIN_BYTES,
+    WEBHOOK_SECRET_PREFIX,
+    WEBHOOK_SIGNATURE_HEADER,
+    WEBHOOK_TIMESTAMP_HEADER,
+    WEBHOOK_TOLERANCE_SECONDS,
+)
+from ._errors import WebhookVerificationError
+from .types import WebhookEvent
+
+__all__ = ["WebhookHeaders", "WebhookVerificationError", "verify"]
+
+_TIMESTAMP_PATTERN = re.compile(r"[0-9]{1,12}")
+_SIGNATURE_VERSION = "v1,"
+
+
+class WebhookHeaders(Protocol):
+    """Request headers: a dict or any framework header object with ``items()`` (Flask, Django, Starlette)."""
+
+    def items(self) -> Iterable[tuple[str, object]]: ...
+
+
+def _read_header(headers: WebhookHeaders, name: str) -> str | None:
+    """Finds a header by name with any key casing; a list value counts only when it holds exactly one string."""
+    for key, value in headers.items():
+        if key.lower() != name:
+            continue
+        if isinstance(value, (list, tuple)) and len(value) == 1:
+            value = value[0]
+        return value if isinstance(value, str) else None
+    return None
+
+
+def _secret_key(secret: str) -> bytes:
+    """The HMAC key of a ``whsec_`` secret: the base64 after the prefix, decoded, and long enough to be a real secret."""
+    encoded = secret[len(WEBHOOK_SECRET_PREFIX) :]
+    try:
+        key = base64.b64decode(encoded + "=" * (-len(encoded) % 4), validate=True)
+    except binascii.Error:
+        key = b""
+    if len(key) < WEBHOOK_SECRET_MIN_BYTES:
+        raise WebhookVerificationError(
+            f"The webhook secret must be whsec_ followed by at least {WEBHOOK_SECRET_MIN_BYTES} bytes in standard base64."
+        )
+    return key
+
+
+def verify(
+    raw_body: bytes | str,
+    headers: WebhookHeaders,
+    secret: str,
+    tolerance: int = WEBHOOK_TOLERANCE_SECONDS,
+) -> WebhookEvent:
+    """Checks the Standard Webhooks signature (any ``v1`` entry, so secret rotations verify) and timestamp age; returns the event.
+
+    Pass the raw body exactly as received; ``tolerance`` is the allowed clock gap in seconds. Raises ``WebhookVerificationError``."""
+    if not isinstance(tolerance, int) or tolerance < 0:
+        raise WebhookVerificationError("tolerance must be a whole number of seconds, 0 or more.")
+    if not isinstance(secret, str) or not secret.startswith(WEBHOOK_SECRET_PREFIX):
+        raise WebhookVerificationError("The webhook secret must start with whsec_.")
+    key = _secret_key(secret)
+
+    message_id = _read_header(headers, WEBHOOK_ID_HEADER)
+    timestamp = _read_header(headers, WEBHOOK_TIMESTAMP_HEADER)
+    signatures = _read_header(headers, WEBHOOK_SIGNATURE_HEADER)
+    if not message_id or not timestamp or not signatures:
+        raise WebhookVerificationError("The webhook-id, webhook-timestamp or webhook-signature header is missing.")
+    if not _TIMESTAMP_PATTERN.fullmatch(timestamp):
+        raise WebhookVerificationError("webhook-timestamp must be a unix time in seconds.")
+
+    body = raw_body.encode("utf-8") if isinstance(raw_body, str) else bytes(raw_body)
+    signed = f"{message_id}.{timestamp}.".encode("utf-8") + body
+    # Compared as exact standard base64 text, as in every Solverr SDK, so no other spelling of the same bytes is accepted.
+    expected = base64.b64encode(hmac.new(key, signed, hashlib.sha256).digest())
+    received = [
+        entry[len(_SIGNATURE_VERSION) :].encode("ascii", "replace")
+        for entry in signatures.split(" ")
+        if entry.startswith(_SIGNATURE_VERSION)
+    ]
+    if not any(hmac.compare_digest(expected, signature) for signature in received):
+        raise WebhookVerificationError(
+            "The webhook signature does not match. Check the webhook secret and pass the raw request body."
+        )
+
+    if abs(int(time.time()) - int(timestamp)) > tolerance:
+        raise WebhookVerificationError(f"The webhook timestamp is more than {tolerance} seconds from the current time.")
+
+    try:
+        event = json.loads(body)
+    except ValueError:
+        raise WebhookVerificationError("The webhook body is not valid JSON.") from None
+    if not isinstance(event, dict):
+        raise WebhookVerificationError("The webhook body is not a JSON object.")
+    return cast(WebhookEvent, event)

solverr-0.1.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.5
+Name: solverr
+Version: 0.1.0
+Summary: Server SDK for the Solverr crypto payment API.
+Project-URL: Homepage, https://github.com/forcequitx/solverr/tree/main/packages/python#readme
+Project-URL: Source, https://github.com/forcequitx/solverr/tree/main/packages/python
+Project-URL: Issues, https://github.com/forcequitx/solverr/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: checkout,crypto,payments,solverr,webhooks
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# <img src="https://github.com/forcequitx/solverr/raw/main/app/icon.svg" alt="Solverr" width="30" height="30"> solverr
+
+**The Python server SDK for the Solverr crypto payment API.**
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/lightbulb.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Overview
+
+Your server uses this SDK to create invoices, payment links, refunds, payouts, subscriptions and credit charges, to list the coins the checkout accepts, and to verify the signed webhooks Solverr sends.
+
+- **Checkout:** your server calls `client.invoices.create` -> the customer pays at the invoice's `checkout_url`.
+- **Webhooks:** Solverr sends a signed `invoice.paid` event -> `solverr.webhooks.verify` checks it and returns the event.
+- **Paid content:** `client.invoices.redeem` marks a paid invoice as used -> one payment grants access only once.
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/package.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Install
+
+The SDK needs Python 3.11 or later, uses only the standard library, and ships type hints.
+
+```bash
+pip install solverr
+```
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/terminal.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Quick Start
+
+Create an invoice and send the customer to checkout:
+
+```python
+import os
+
+from solverr import Solverr
+
+client = Solverr(
+    api_key=os.environ["SOLVERR_SECRET_KEY"],  # sk_live_…
+    base_url=os.environ["SOLVERR_URL"],  # the origin of your Solverr app
+)
+
+invoice = client.invoices.create(
+    amount="25.00",
+    currency="USD",
+    order_id="1042",
+    redirect_url="https://shop.example/thanks",
+)
+
+# Redirect the customer to invoice["checkout_url"]
+```
+
+`base_url` can be left out when the `SOLVERR_URL` environment variable is set. It must be an https URL. Plain http works only for `localhost`, `127.0.0.1` and `[::1]`, so your API key never travels unencrypted. Arguments and response keys use the API's own field names (`order_id`, `checkout_url`), so the API reference applies as written. Responses are plain dictionaries, typed with the `TypedDict` classes in `solverr.types`.
+
+Every key is a live key, so every invoice you create takes real payments. To see the checkout without moving real money, open the demo store at `/demo` on the Solverr app that `base_url` points to.
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/bell.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Webhooks
+
+Confirm a payment with a webhook. Pass the raw request body exactly as it arrived: parsed and re-serialized JSON will not match the signature.
+
+```python
+import os
+
+from flask import Flask, request
+
+import solverr
+
+app = Flask(__name__)
+
+
+@app.post("/webhooks/solverr")
+def solverr_webhook():
+    try:
+        event = solverr.webhooks.verify(
+            request.get_data(),
+            request.headers,
+            os.environ["SOLVERR_WEBHOOK_SECRET"],
+        )
+    except solverr.WebhookVerificationError as error:
+        return str(error), 400
+
+    if event["type"] == "invoice.paid":
+        mark_order_paid(event["data"]["invoice"]["order_id"])
+    return "", 200
+```
+
+In Django, pass `request.body` and `request.headers`. In FastAPI or Starlette, pass `await request.body()` and `request.headers`.
+
+### How `verify` checks an event
+
+- `verify` checks the Standard Webhooks signature. The `webhook-signature` header holds `v1,` and the base64 HMAC-SHA256 of `id.timestamp.body` (`webhook-id`, `webhook-timestamp` and the raw body). The HMAC key is the part of the secret after `whsec_`, decoded from base64.
+- Any `v1` entry may match, so events signed with both secrets during a rotation still pass.
+- It compares the exact standard base64 text with `hmac.compare_digest`, so an unpadded or URL-safe spelling of a valid signature is refused.
+- It rejects events whose `webhook-timestamp` is more than 300 seconds from now. Change that window with `tolerance=`, in seconds.
+- Header names can use any casing.
+- The same event can arrive more than once, so use `event["id"]` to skip events you already handled.
+
+Each business has one webhook URL and one signing secret.
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/boxes.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Resources
+
+| Call | Endpoint |
+| --- | --- |
+| `invoices.create(amount=, currency=, order_id=, description=, redirect_url=, customer_email=, metadata=, expires_in=, idempotency_key=)` | `POST /api/v1/invoices` |
+| `invoices.retrieve(invoice_id)` | `GET /api/v1/invoices/:id` |
+| `invoices.list(limit=, starting_after=, status=)` | `GET /api/v1/invoices` |
+| `invoices.list_all(limit=, starting_after=, status=)` | Iterator over every matching invoice, fetching the next page as the loop goes on |
+| `invoices.redeem(invoice_id)` | `POST /api/v1/invoices/:id/redeem` |
+| `payment_links.create(title=, currency=, amount=, redirect_url=)`, `payment_links.list()` | `/api/v1/payment-links` |
+| `payment_links.deactivate(link_id)` | `DELETE /api/v1/payment-links/:id` |
+| `refunds.create(invoice_id=, payment_id=, amount=)`, `refunds.list()` | `/api/v1/refunds` |
+| `payouts.create(recipient=, asset_id=, amount=)`, `payouts.list()` | `/api/v1/payouts` |
+| `payouts.create_batch(payouts=[{"recipient": …, "asset_id": …, "amount": …}, …])` | `POST /api/v1/payouts/batch` |
+| `refunds.retrieve(refund_id)`, `payouts.retrieve(payout_id)` | `GET /api/v1/refunds/:id`, `GET /api/v1/payouts/:id` |
+| `refunds.cancel(refund_id)`, `payouts.cancel(payout_id)` | `POST /api/v1/refunds/:id/cancel`, `POST /api/v1/payouts/:id/cancel` |
+| `subscriptions.create(customer_email=, amount=, currency=, interval=, description=)`, `subscriptions.list()` | `/api/v1/subscriptions` |
+| `subscriptions.cancel(subscription_id)` | `DELETE /api/v1/subscriptions/:id` |
+| `credits.topup(amount=, currency=, credit_account_id=)` | `POST /api/v1/credits/topup` |
+| `credits.charge(token=, amount=, currency=, description=)` | `POST /api/v1/credits/charge` |
+| `credits.refund_charge(charge_id)` | `POST /api/v1/credits/charges/:id/refund` |
+| `tokens.list()` | `GET /api/v1/tokens` |
+| `webhooks.send_test()` | `POST /api/v1/webhooks/test` |
+| `solverr.webhooks.verify(raw_body, headers, secret, tolerance=300)` | Local check, no request |
+
+In the resource calls, every argument except an id is keyword-only. `solverr.webhooks.verify` takes its arguments by position. Every `create`, `create_batch`, `topup`, `charge`, `refund_charge` and `redeem` call, and `refunds.cancel` and `payouts.cancel`, also takes `idempotency_key=`.
+
+Credit balances are kept in USD: `credits.topup` needs `currency="USD"`, and `credits.charge` accepts only `"USD"` when you pass a currency.
+
+### Refunds and payouts
+
+`refunds.create` refunds the payment that paid the invoice. To refund an extra payment on the same invoice, pass its id as `payment_id=`. Leave out `amount=` to refund what is left of that payment.
+
+The `asset_id=` of a payout is the coin the recipient receives. Take it from `tokens.list()`, which returns every coin the checkout accepts, with its chain, decimals and USD price.
+
+### Lists and pages
+
+Every list call except `tokens.list()` returns `{"object": "list", "data": [...], "has_more": bool}`. To get the next page, pass the last item's id as `starting_after`, or loop over `list_all()`:
+
+```python
+for invoice in client.invoices.list_all(status="paid"):
+    print(invoice["id"])
+```
+
+`tokens.list()` returns every coin in one `{"object": "list", "data": [...]}` response, without pages.
+
+### Grant access once per paid invoice
+
+`invoices.redeem(invoice_id)` marks a paid invoice as used. Call it before you deliver a download or show paid content, so one payment cannot be used twice.
+
+```python
+from solverr import SolverrError
+
+try:
+    client.invoices.redeem(invoice_id)
+    # deliver the content
+except SolverrError as error:
+    if error.status == 409:
+        ...  # error.type is "invalid_state" (not paid) or "already_redeemed"
+    else:
+        raise
+```
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/triangle-alert.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Errors and Retries
+
+API errors raise `solverr.SolverrError` with these attributes:
+
+| Attribute | Meaning |
+| --- | --- |
+| `status` | The HTTP status, or `0` when the API cannot be reached. |
+| `type` | The error type, or `connection_error` when the API cannot be reached. |
+| `message` | The error message. |
+| `param` | The invalid field, when a field is invalid. |
+| `code` | A finer reason, when the API adds one. None of the endpoints this SDK calls send one today. |
+| `retry_after` | The seconds the API asked you to wait, on a `429` for example. |
+
+```python
+from solverr import SolverrError
+
+try:
+    client.invoices.create(amount="0", currency="USD")
+except SolverrError as error:
+    print(error.status, error.type, error.param, error.message)
+    # 400 invalid_request amount amount must be greater than 0.
+```
+
+### Timeouts and retries
+
+Each attempt allows 15 seconds to connect and 15 seconds for each wait on the network. The SDK stops reading the response body once 15 seconds have passed since the attempt began.
+
+| Response | How the SDK retries |
+| --- | --- |
+| A timeout, a network error or a 5xx response | Twice, with a growing delay. |
+| A `429` (rate limit), or a `409` that says an earlier request with the same `Idempotency-Key` is still being processed | Up to three times, after the wait in its `Retry-After` header. When `Retry-After` asks for more than 10 seconds, the error is raised right away. |
+
+With those retries, one call ends after about 47 seconds when the server does not answer at all. A slow connection or slow response headers can make it longer, and `Retry-After` retries add to that.
+
+### Idempotency keys
+
+Every POST carries an `Idempotency-Key` header. The SDK generates one when you do not pass one, and every retry sends the same key, so a retried POST never creates a second object. Pass your own key to make retries across process restarts safe too.
+
+A key belongs to the business for 24 hours and covers every endpoint. Give each operation its own key, for example `invoice-order-1042` for the invoice of order 1042 and `refund-order-1042` for its refund, not the order id alone. If you send a key again with a different request (another body or another endpoint), the API answers `409` with type `idempotency_conflict`, and the SDK raises it without a retry.
+
+```python
+invoice = client.invoices.create(
+    amount="25.00",
+    currency="USD",
+    order_id="1042",
+    idempotency_key="invoice-order-1042",
+)
+```
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/shield-check.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> Tests
+
+The tests use only the standard library (`unittest`) and need no install step: `tests/__init__.py` puts `src` on the import path. HTTP tests run against a local server on `127.0.0.1` and never reach a real host. Webhook tests generate their own secrets. From this folder, run:
+
+```bash
+python -I -m unittest
+```
+
+CI names the test folder explicitly: `python -I -m unittest discover -s tests -t .`. The `-t .` makes `tests` load as a package.
+
+## <img src="https://github.com/forcequitx/solverr/raw/main/assets/icons/file-text.svg" width="24" height="24" style="vertical-align: middle; margin-right: 4px;"> License
+
+Released under the **MIT License**.

solverr-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+solverr/__init__.py,sha256=jhBp6PHxu3kJJ9BY8MQ4OV9MaVLaCXCvTErZbtdb-No,324
+solverr/_client.py,sha256=Glh4RpOAmaz6W3n3XoIqWSL4fx3Wq6wmRdr_VhaTXrE,2239
+solverr/_config.py,sha256=vryLiheKpNcvPNmNSTYnVNxTw4CGmVUSdZu010Nr-es,1316
+solverr/_errors.py,sha256=8AKdOQ9pA37mpFBUtis23pFcyJOfBBzJTDyi96hSBx4,1502
+solverr/_http.py,sha256=Xisbwh-c_VCcY0uvH0aJHrkKEVB6t83hIriVwbyFR40,8386
+solverr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+solverr/types.py,sha256=vWP5HQGwunkm2opFgc2X3GhDXVKKI_1EkIet2DcZPjw,6742
+solverr/webhooks.py,sha256=94w_AKNY1wl_2tFIzr2ouyAb-fyS8TDmJk6jboH85js,4480
+solverr/resources/__init__.py,sha256=xJ3RAS0Ba_8bfG-jZkPFTA4pI7Puqfd_V4GCqHRImFw,369
+solverr/resources/credits.py,sha256=0vjzY2n1sVQgRYrbZ-1gFxyZEQy0W1ySW3-SUChvxk0,1995
+solverr/resources/invoices.py,sha256=NgZO-AW7mmAOzp5Pd6vB6kGioIvSJ6z9roZFLjKJpLw,3115
+solverr/resources/payment_links.py,sha256=tAyQxT3JCdsmo6gVYxrO2XszYMdf6WdAP3JvldymNkw,1472
+solverr/resources/payouts.py,sha256=RgB06IK1Q35VIyoowBleZSB-Qm5_zaJSGk8lYLbFfD0,2155
+solverr/resources/refunds.py,sha256=lvmh6rj0V8pWoFnvwxiMmqqXov8tK2BZh5dxBnf5Gtg,1717
+solverr/resources/subscriptions.py,sha256=qVHt-D1D_OAgSOlIdChJ_oKFWaFr7SuRIQzS_aGNmbU,1585
+solverr/resources/tokens.py,sha256=xIeuOhJBODrmwAxHgRPwSyUkr_HTL8pUQyg67t3FyqI,433
+solverr/resources/webhooks.py,sha256=JFKum3UyXMcVEorEH6HXUxGKWEVChC_86U0VY1oMX2w,472
+solverr-0.1.0.dist-info/METADATA,sha256=_PO2wm0S_2QkGB5o5vbLHw0Gul4ZK_3T2Zf-2yY9Avs,12481
+solverr-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+solverr-0.1.0.dist-info/licenses/LICENSE,sha256=mD8ZhPyM7NV8ggWJBWGGu1PEo_stzEj1f884JJRp-O0,1064
+solverr-0.1.0.dist-info/RECORD,,

solverr-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

solverr-0.1.0.dist-info/licenses/LICENSE

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