phala-pay 0.2.0__py3-none-any.whl

phala_pay/__init__.py

@@ -0,0 +1,96 @@
+"""Phala Pay for Python, in the shape of Stripe's.
+
+    import os
+
+    from phala_pay import PhalaPay
+
+    pay = PhalaPay(
+        api_base="https://pay.example.com",
+        api_key=os.environ["PHALA_PAY_KEY"],
+        forwarder=(FACTORY, IMPLEMENTATION),
+    )
+    quote = pay.quotes.create(
+        client_reference_id="team-42", amount=2500, chain_id=11155111, asset="pha"
+    )
+
+    event = pay.webhooks.construct_event(
+        raw_body, request.headers, WEBHOOK_PUBLIC_KEY, "acct_…", expected_livemode=False
+    )
+    if event.type == "deposit.credited":
+        credit_once(event.deposit.id, event.deposit.client_reference_id, event.deposit.amount)
+
+`topup_sdk` holds the lower-level pieces (address derivation, attestation, webhook and admin
+request signatures, offline `flush_transaction` and `safe_batch`, `export_account`) and
+`topup_client` the client generated from the OpenAPI document.
+"""
+
+from topup_client.models import (
+    Balance,
+    ClientQuote,
+    Config,
+    Deposit,
+    DepositAddress,
+    Forwarder,
+    Quote,
+    Refund,
+    Sweep,
+    Treasury,
+)
+from topup_sdk import (
+    AddressMismatchError,
+    ApiError,
+    TopupError,
+    flush_transaction,
+    flush_transactions,
+    safe_batch,
+    write_safe_batch,
+)
+
+from ._client import PhalaPay
+from ._types import (
+    ApiKeyStatus,
+    DepositAddressStatus,
+    DepositStatus,
+    EventType,
+    PaymentStatus,
+    QuoteStatus,
+    RefundStatus,
+    TreasuryStatus,
+    WebhookEndpointStatus,
+)
+from ._webhook import Event, EventData, EventRequest, SignatureVerificationError, Webhook
+
+__all__ = [
+    "AddressMismatchError",
+    "ApiError",
+    "ApiKeyStatus",
+    "Balance",
+    "ClientQuote",
+    "Config",
+    "Deposit",
+    "DepositAddress",
+    "DepositAddressStatus",
+    "DepositStatus",
+    "Event",
+    "EventData",
+    "EventRequest",
+    "EventType",
+    "Forwarder",
+    "PaymentStatus",
+    "PhalaPay",
+    "Quote",
+    "QuoteStatus",
+    "Refund",
+    "RefundStatus",
+    "SignatureVerificationError",
+    "Sweep",
+    "TopupError",
+    "Treasury",
+    "TreasuryStatus",
+    "Webhook",
+    "WebhookEndpointStatus",
+    "flush_transaction",
+    "flush_transactions",
+    "safe_batch",
+    "write_safe_batch",
+]

phala_pay/_client.py

@@ -0,0 +1,582 @@
+"""`PhalaPay`: the Phala Pay merchant API as Stripe-style resources over `TopupClient`."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from pathlib import Path
+
+import httpx
+
+from topup_client.models import (
+    AccountObject,
+    ApiKeyObject,
+    Balance,
+    Config,
+    DeletedWebhookEndpoint,
+    Deposit,
+    DepositAddress,
+    EventObjectResponse,
+    Forwarder,
+    Quote,
+    Refund,
+    Sweep,
+    Treasury,
+    TreasuryChallenge,
+    WebhookEndpointObject,
+)
+from topup_sdk import TopupClient, export_account, sign_treasury_challenge
+from topup_sdk.client import Metadata
+
+from ._types import (
+    DepositAddressStatus,
+    DepositStatus,
+    EventType,
+    QuoteStatus,
+    RefundStatus,
+    TreasuryStatus,
+)
+from ._webhook import Webhook
+
+
+class PhalaPay:
+    """A client for one account and mode, authenticated with its API key.
+
+        pay = PhalaPay(
+            api_base="https://pay.example.com",
+            api_key=os.environ["PHALA_PAY_KEY"],
+            account="acct_…",
+            forwarder=(FACTORY, IMPLEMENTATION),
+            treasuries={1: "0x…your treasury on Ethereum"},
+        )
+        quote = pay.quotes.create(client_reference_id="team-42", amount=2500,
+                                  chain_id=11155111, asset="pha")
+        return {"client_secret": quote.client_secret, "expected_address": quote.address}
+
+    `api_key` is a restricted key (`ppay_rk_…`, recommended for a production server) or a secret
+    key (`ppay_sk_…`, for administration); the key selects the account and the mode. Every quote
+    and deposit address is recomputed before it is returned from pins you configure yourself:
+    `forwarder`, the `(factory, implementation)` pair pinned from the attested deployment;
+    `treasuries` (`{chain_id: treasury}`), your own treasury per chain; and `account` (`acct_…`).
+    The service's `treasury` is never trusted, and an address you cannot derive raises
+    `AddressMismatchError` (fail closed). A live key requires all three pins: without them every
+    address check raises. In test mode `account` is read from `GET /v1/account` when not given,
+    and without `treasuries` the service's treasury is used with an `UnpinnedTreasuryWarning`.
+
+    Requests that fail with a transport error, `429` (after its `Retry-After`), or `5xx` are
+    retried with backoff; `POST`s reuse one `Idempotency-Key` across retries, so a retry never
+    creates a second object, and a response the service saved for the key (even a `500`) is
+    returned as it was, not retried. A failed request raises `ApiError` with the service's
+    `code`, `param`, `doc_url`, and `request_id`.
+    """
+
+    def __init__(
+        self,
+        api_base: str,
+        api_key: str,
+        *,
+        forwarder: tuple[str, str],
+        treasuries: Mapping[int, str] | None = None,
+        account: str | None = None,
+        timeout: float = 15.0,
+        max_attempts: int = 4,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._client = TopupClient(
+            api_base,
+            api_key,
+            account=account,
+            forwarder=forwarder,
+            treasuries=treasuries,
+            timeout=timeout,
+            max_attempts=max_attempts,
+            transport=transport,
+        )
+        self.account = AccountResource(self._client)
+        self.config = ConfigResource(self._client)
+        self.quotes = Quotes(self._client)
+        self.deposits = Deposits(self._client)
+        self.deposit_addresses = DepositAddresses(self._client)
+        self.refunds = Refunds(self._client)
+        self.balance = BalanceResource(self._client)
+        self.sweeps = Sweeps(self._client)
+        self.forwarders = Forwarders(self._client)
+        self.treasuries = Treasuries(self._client)
+        self.api_keys = ApiKeys(self._client)
+        self.webhook_endpoints = WebhookEndpoints(self._client)
+        self.events = Events(self._client)
+        self.webhooks = Webhook
+
+    def export_account(self, directory: str | Path) -> dict[str, int]:
+        """Writes every object of the key's account and mode to `directory`, one JSON file per
+        resource, and returns the counts (design §13). `forwarders.json` keeps funds sweepable
+        without Phala Pay."""
+        return export_account(self._client, directory)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> PhalaPay:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+
+class AccountResource:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def retrieve(self) -> AccountObject:
+        """The key's account, in the key's mode."""
+        return self._client.get_account()
+
+    def update(self, *, confirmation_policies: Mapping[int, str | None]) -> AccountObject:
+        """Requires, per chain, a confirmation stricter than the route's before a payment is
+        credited: a depth such as `"12"`, `"safe"`, or `"finalized"`; `None` restores the
+        route's."""
+        return self._client.update_account(confirmation_policies=confirmation_policies)
+
+    def pause_quotes(self) -> AccountObject:
+        """Stops issuing quotes, deposit addresses, and networks in both modes, for an
+        emergency; existing addresses keep being credited."""
+        return self._client.pause_quotes()
+
+    def resume_quotes(self) -> AccountObject:
+        """Lifts your own `quotes` pause; an operator's pause stays."""
+        return self._client.resume_quotes()
+
+    def roll_webhook_key(self, *, expires_in: int = 172_800) -> AccountObject:
+        """Rolls this mode's webhook signing key; the old one signs beside it for `expires_in`
+        seconds: 48 hours (the default) to 7 days live, `0` to 7 days in test mode."""
+        return self._client.roll_webhook_key(expires_in=expires_in)
+
+
+class ConfigResource:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def retrieve(self) -> Config:
+        """The payable assets, limits, quote terms, and confirmations, for the product's UI."""
+        return self._client.get_config()
+
+
+class Quotes:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        client_reference_id: str,
+        amount: int,
+        chain_id: int,
+        asset: str,
+        currency: str = "usd",
+        idempotency_key: str | None = None,
+        metadata: Mapping[str, str] | None = None,
+    ) -> Quote:
+        """Quotes `amount` cents for the customer `client_reference_id`, payable in `asset` on
+        `chain_id`.
+
+        Only this response carries `client_secret`, the value the payer's browser needs, beside
+        the recomputed `address` to pass as `<Checkout expectedAddress>`. Pass an
+        `idempotency_key` of your own (for example your order id) to resume a checkout: for 24
+        hours a repeat of the same request replays the first response, the same quote and the
+        same `client_secret` included.
+
+        `metadata` is Stripe's: up to 50 string pairs for your own use, such as your order id,
+        copied to the deposit that pays the quote. Do not store sensitive information in it.
+        """
+        return self._client.create_quote(
+            client_reference_id,
+            amount,
+            chain_id=chain_id,
+            asset=asset,
+            currency=currency,
+            idempotency_key=idempotency_key,
+            metadata=metadata,
+        )
+
+    def retrieve(self, quote_id: str) -> Quote:
+        return self._client.get_quote(quote_id)
+
+    def list(
+        self, *, client_reference_id: str | None = None, status: QuoteStatus | None = None
+    ) -> Iterator[Quote]:
+        """Yields every matching quote, newest first, fetching pages as it goes."""
+        return self._client.list_quotes(client_reference_id=client_reference_id, status=status)
+
+    def update(self, quote_id: str, *, metadata: Metadata | None = None) -> Quote:
+        """Merges `metadata` into the quote's: a key set to `""` is unset, and `metadata=""`
+        unsets every key."""
+        return self._client.update_quote(quote_id, metadata=metadata)
+
+    def cancel(self, quote_id: str) -> Quote:
+        """Cancels an open quote no payment has reached; repeating it returns the canceled quote."""
+        return self._client.cancel_quote(quote_id)
+
+
+class Deposits:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    # Before `list`, whose name would shadow the builtin in later annotations.
+    def retrieve(self, deposit_id: str, *, expand: list[str] | None = None) -> Deposit:
+        return self._client.get_deposit(deposit_id, expand=expand)
+
+    def update(self, deposit_id: str, *, metadata: Metadata | None = None) -> Deposit:
+        """Merges `metadata` into the deposit's, which started as a copy of its quote's or its
+        deposit address's; theirs are left unchanged."""
+        return self._client.update_deposit(deposit_id, metadata=metadata)
+
+    def list(
+        self,
+        *,
+        client_reference_id: str | None = None,
+        quote: str | None = None,
+        deposit_address: str | None = None,
+        status: DepositStatus | None = None,
+        tx_hash: str | None = None,
+        created_gt: int | None = None,
+        created_gte: int | None = None,
+        created_lt: int | None = None,
+        created_lte: int | None = None,
+        expand: list[str] | None = None,
+    ) -> Iterator[Deposit]:
+        """Yields every matching deposit, newest first, fetching pages as it goes. `created_*`
+        are Unix seconds (Stripe's `created[gt|gte|lt|lte]`)."""
+        return self._client.list_deposits(
+            client_reference_id=client_reference_id,
+            quote=quote,
+            deposit_address=deposit_address,
+            status=status,
+            tx_hash=tx_hash,
+            created_gt=created_gt,
+            created_gte=created_gte,
+            created_lt=created_lt,
+            created_lte=created_lte,
+            expand=expand,
+        )
+
+
+class DepositAddresses:
+    """A customer's persistent deposit address: one address for every supported token on every
+    supported network. Show it like a bank account number; any amount of a supported token sent
+    to it is credited at the market rate when it arrives. `networks` lists each chain's address
+    (the same wherever the treasury is the same; `address` is it when all agree) and tokens, and
+    `payments` the transfers seen and recorded in the last 24 hours.
+
+    `topup_sdk.deposit_address(...)` recomputes any version offline from its salt inputs and a
+    network's treasury.
+    """
+
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        client_reference_id: str,
+        metadata: Metadata | None = None,
+    ) -> DepositAddress:
+        """Returns the customer's active address, recomputed; the same call keeps returning it
+        until it is rotated, and adds a network supported since. Each response carries a new
+        `client_secret` for the customer's page (`<DepositAddress clientSecret>`) to follow
+        payments. `metadata` is merged into the address's; each deposit to it starts with a
+        copy, and a rotation carries it to the next address."""
+        return self._client.create_deposit_address(client_reference_id, metadata=metadata)
+
+    def update(
+        self, deposit_address_id: str, *, metadata: Metadata | None = None
+    ) -> DepositAddress:
+        """Merges `metadata` into the address's (a key set to `""` is unset, `""` unsets all)."""
+        return self._client.update_deposit_address(deposit_address_id, metadata=metadata)
+
+    def retrieve(self, deposit_address_id: str) -> DepositAddress:
+        return self._client.get_deposit_address(deposit_address_id)
+
+    def list(
+        self,
+        *,
+        client_reference_id: str | None = None,
+        status: DepositAddressStatus | None = None,
+    ) -> Iterator[DepositAddress]:
+        """Yields every matching deposit address, newest first, fetching pages as it goes."""
+        return self._client.list_deposit_addresses(
+            client_reference_id=client_reference_id, status=status
+        )
+
+    def rotate(
+        self, deposit_address_id: str, *, idempotency_key: str | None = None
+    ) -> DepositAddress:
+        """Retires the address and returns the customer's new one, a new address on every
+        network; the retired address is still credited, so stop showing it rather than telling
+        the customer it is invalid."""
+        return self._client.rotate_deposit_address(
+            deposit_address_id, idempotency_key=idempotency_key
+        )
+
+
+class Refunds:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        deposit: str,
+        destination_address: str,
+        amount_atomic: int | None = None,
+        idempotency_key: str | None = None,
+        metadata: Mapping[str, str] | None = None,
+    ) -> Refund:
+        """Creates a pending refund of a final `deposit` (its unrefunded remainder unless
+        `amount_atomic` is given) to an address the customer controls; pay it from its
+        `treasury`, then call `mark_paid`."""
+        return self._client.create_refund(
+            deposit,
+            destination_address,
+            amount_atomic,
+            idempotency_key=idempotency_key,
+            metadata=metadata,
+        )
+
+    def mark_paid(
+        self, refund_id: str, *, transaction_hash: str, receipt_log_index: int | None = None
+    ) -> Refund:
+        """Attaches the transaction that pays the refund; it is verified at finality. From then
+        on the refund cannot be canceled: it stays pending until it succeeds, or fails when the
+        transaction does not pay it or is proven dropped."""
+        return self._client.mark_refund_paid(
+            refund_id, transaction_hash, receipt_log_index=receipt_log_index
+        )
+
+    def cancel(self, refund_id: str) -> Refund:
+        """Cancels a pending refund."""
+        return self._client.cancel_refund(refund_id)
+
+    def retrieve(self, refund_id: str, *, expand: list[str] | None = None) -> Refund:
+        return self._client.get_refund(refund_id, expand=expand)
+
+    def update(self, refund_id: str, *, metadata: Metadata | None = None) -> Refund:
+        """Merges `metadata` into the refund's."""
+        return self._client.update_refund(refund_id, metadata=metadata)
+
+    def list(
+        self, *, deposit: str | None = None, status: RefundStatus | None = None
+    ) -> Iterator[Refund]:
+        """Yields every matching refund, newest first, fetching pages as it goes."""
+        return self._client.list_refunds(deposit=deposit, status=status)
+
+
+class BalanceResource:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def retrieve(self) -> Balance:
+        """What the account's forwarders hold, per chain and token, and the final part of it."""
+        return self._client.get_balance()
+
+
+class Sweeps:
+    """Sweeps: finalized `Flushed` events that moved a forwarder's balance to its treasury.
+    Build the `flush` calls offline with `topup_sdk.flush_transactions` from
+    `forwarders.list(sweepable=token)`, and for a Safe treasury write them with
+    `topup_sdk.safe_batch`."""
+
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        chain_id: int | None = None,
+        forwarder: str | None = None,
+        token: str | None = None,
+    ) -> Iterator[Sweep]:
+        """Yields the sweeps, newest first, fetching pages as it goes."""
+        return self._client.list_sweeps(chain_id=chain_id, forwarder=forwarder, token=token)
+
+
+class Forwarders:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        chain_id: int | None = None,
+        quote: str | None = None,
+        deposit_address: str | None = None,
+        sweepable: str | None = None,
+    ) -> Iterator[Forwarder]:
+        """Yields the account's forwarders with their `(factory, salt, treasury)`: all of them, or
+        those of one `quote` or `deposit_address`; with `sweepable` (a token contract), only those
+        safe to sweep of it."""
+        return self._client.list_forwarders(
+            chain_id=chain_id, quote=quote, deposit_address=deposit_address, sweepable=sweepable
+        )
+
+
+class Treasuries:
+    """Treasuries, proven through the API (design D10): an EOA signs the challenge with
+    `set_eoa`; a Safe's owners sign it as a Safe message and `create` submits it
+    (docs/integration.md, "Set a Safe as treasury")."""
+
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def challenge(self, *, chain_id: int, address: str) -> TreasuryChallenge:
+        """The EIP-4361 message that proves `address` as the treasury of `chain_id`."""
+        return self._client.create_treasury_challenge(chain_id, address)
+
+    def create(self, *, chain_id: int, message: str, signature: str) -> Treasury:
+        """Submits a signed challenge `message`."""
+        return self._client.create_treasury(chain_id, message, signature)
+
+    def set_eoa(self, *, chain_id: int, address: str, private_key: str | bytes) -> Treasury:
+        """Proves the EOA `address` as the treasury of `chain_id`: requests a challenge, signs it
+        with `private_key` (which must be `address`'s; needs `phala-pay[eoa]`), and submits it."""
+        challenge = self.challenge(chain_id=chain_id, address=address)
+        signature = sign_treasury_challenge(challenge.message, private_key, address=address)
+        return self.create(chain_id=chain_id, message=challenge.message, signature=signature)
+
+    def retrieve(self, treasury_id: str) -> Treasury:
+        return self._client.get_treasury(treasury_id)
+
+    def list(
+        self, *, chain_id: int | None = None, status: TreasuryStatus | None = None
+    ) -> list[Treasury]:
+        """The treasuries of this mode, newest first."""
+        return self._client.list_treasuries(chain_id=chain_id, status=status)
+
+    def cancel(self, treasury_id: str) -> Treasury:
+        """Cancels a pending treasury change before it applies."""
+        return self._client.cancel_treasury(treasury_id)
+
+    def pause(self, treasury_id: str) -> Treasury:
+        """Pauses crediting of deposits to every forwarder over the treasury, for an incident
+        such as a compromised former treasury: they stay `pending` until `resume`."""
+        return self._client.pause_treasury(treasury_id)
+
+    def resume(self, treasury_id: str) -> Treasury:
+        """Lifts your crediting pause; an operator's pause stays."""
+        return self._client.resume_treasury(treasury_id)
+
+
+class ApiKeys:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def create(self, *, name: str = "", permissions: Sequence[str] | None = None) -> ApiKeyObject:
+        """A new key of this mode; its `secret` is in this response only. With `permissions`
+        (such as `["quotes.write", "deposit_addresses.write", "deposits.read", "events.read",
+        "refunds.read", "account.read"]`) it is a restricted key, `ppay_rk_…`, which never
+        manages keys, treasuries, webhook endpoints, webhook keys, or account settings: run
+        production with one and keep the secret key offline."""
+        return self._client.create_api_key(name=name, permissions=permissions)
+
+    def retrieve(self, api_key_id: str) -> ApiKeyObject:
+        return self._client.get_api_key(api_key_id)
+
+    def list(self) -> list[ApiKeyObject]:
+        """This mode's keys, without their secrets."""
+        return self._client.list_api_keys()
+
+    def roll(self, api_key_id: str, *, expires_in: int = 0) -> ApiKeyObject:
+        """A replacement key of the same kind and permissions with its `secret`; the old one
+        works for `expires_in` seconds."""
+        return self._client.roll_api_key(api_key_id, expires_in=expires_in)
+
+    def revoke(self, api_key_id: str) -> ApiKeyObject:
+        return self._client.revoke_api_key(api_key_id)
+
+
+class WebhookEndpoints:
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        url: str,
+        enabled_events: list[str],
+        description: str | None = None,
+        metadata: Mapping[str, str] | None = None,
+    ) -> WebhookEndpointObject:
+        return self._client.create_webhook_endpoint(
+            url, enabled_events, description=description, metadata=metadata
+        )
+
+    def retrieve(self, endpoint_id: str) -> WebhookEndpointObject:
+        return self._client.get_webhook_endpoint(endpoint_id)
+
+    def update(
+        self,
+        endpoint_id: str,
+        *,
+        url: str | None = None,
+        enabled_events: list[str] | None = None,
+        description: str | None = None,
+        disabled: bool | None = None,
+        metadata: Metadata | None = None,
+    ) -> WebhookEndpointObject:
+        return self._client.update_webhook_endpoint(
+            endpoint_id,
+            url=url,
+            enabled_events=enabled_events,
+            description=description,
+            disabled=disabled,
+            metadata=metadata,
+        )
+
+    def delete(self, endpoint_id: str) -> DeletedWebhookEndpoint:
+        return self._client.delete_webhook_endpoint(endpoint_id)
+
+    def test(self, endpoint_id: str) -> EventObjectResponse:
+        """Sends a test event to the endpoint."""
+        return self._client.test_webhook_endpoint(endpoint_id)
+
+    def list(self) -> Iterator[WebhookEndpointObject]:
+        return self._client.list_webhook_endpoints()
+
+
+class Events:
+    """Events of this mode: every webhook ever sent, and the account's audit log."""
+
+    def __init__(self, client: TopupClient) -> None:
+        self._client = client
+
+    def retrieve(self, event_id: str) -> EventObjectResponse:
+        return self._client.get_event(event_id)
+
+    def resend(self, event_id: str, *, webhook_endpoint: str) -> EventObjectResponse:
+        """Delivers the event again to one enabled endpoint."""
+        return self._client.resend_event(event_id, webhook_endpoint=webhook_endpoint)
+
+    def list(
+        self,
+        *,
+        type: EventType | str | None = None,
+        types: Sequence[EventType | str] | None = None,
+        delivery_success: bool | None = None,
+        created_gt: int | None = None,
+        created_gte: int | None = None,
+        created_lt: int | None = None,
+        created_lte: int | None = None,
+    ) -> Iterator[EventObjectResponse]:
+        """Yields events, newest first. `type` filters by one type, such as `deposit.reversed`,
+        or a group, `deposit.*`; `types` by up to 20. `delivery_success=False` yields the events
+        a webhook endpoint has not received: its `pending_deliveries`, `oldest_pending_at`, and
+        `last_attempt` say whether it is keeping up; resend the missed events once it is fixed.
+        `data.object` is the object as it was when the event happened; `*.updated` events carry
+        `data.previous_attributes`, and events caused by your requests their `request`."""
+        return self._client.list_events(
+            type=type,
+            types=types,
+            delivery_success=delivery_success,
+            created_gt=created_gt,
+            created_gte=created_gte,
+            created_lt=created_lt,
+            created_lte=created_lte,
+        )