noxy-sdk 1.0.0__tar.gz

noxy_sdk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Noxy Network (noxy.network)
+
+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.

noxy_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: noxy-sdk
+Version: 1.0.0
+Summary: Backend SDK for Python servers to integrate with the Noxy push notification network
+Author: Noxy Network
+License: MIT
+Keywords: noxy,push-notifications,web3,post-quantum,grpc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio>=1.60.0
+Requires-Dist: grpcio-tools>=1.60.0
+Requires-Dist: protobuf>=4.25.0
+Requires-Dist: kybercffi>=1.0.0
+Requires-Dist: cryptography>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# 📦 @noxy-network/python-sdk
+
+Backend SDK for Python servers to integrate with the [Noxy](https://noxy.network) push notification network. Send encrypted push notifications to Web3 wallet addresses via the Noxy relay infrastructure.
+
+## Overview
+
+This SDK enables server-side applications to:
+
+- **Send push notifications** to users by their Web3 wallet address (EVM `0x` format)
+- **Query quota usage** for your application's relay allocation
+- **Resolve identity devices** to deliver notifications to all registered devices
+
+Communication with the Noxy relay is performed over **gRPC** using Protocol Buffers. All notifications are **encrypted end-to-end** on the backend before transmission; decryption occurs only on the recipient's Noxy device. The SDK uses **post-quantum encryption** (Kyber768) to protect payloads against future quantum attacks.
+
+## Architecture
+
+```
+┌─────────────────┐     gRPC (TLS)      ┌─────────────────┐     E2E Encrypted     ┌─────────────────┐
+│  Your Backend   │ ◄─────────────────► │  Noxy Relay     │ ◄──────────────────► │  Noxy Device    │
+│  (this SDK)     │   PushNotification  │                 │   Ciphertext only    │  (decrypts)      │
+│                 │   GetQuota          │                 │                      │                 │
+│                 │   GetIdentityDevices│                 │                      │                 │
+└─────────────────┘                     └─────────────────┘                      └─────────────────┘
+```
+
+- **Encryption**: Kyber768 (post-quantum KEM) + AES-256-GCM. Each notification is encrypted per-device using the device's post-quantum public key.
+- **Transport**: gRPC over TLS with Bearer token authentication.
+- **Relay**: The Noxy relay forwards ciphertext only; it cannot decrypt notification payloads.
+
+## Requirements
+
+- Python **>= 3.10**
+- C compiler (for kybercffi)
+
+## 🚀 Installation
+
+```bash
+pip install noxy-sdk
+```
+
+## 🛠 Quick Start
+
+```python
+from noxy import NoxyConfig, init_noxy_client
+
+config = NoxyConfig(
+    endpoint="https://relay.noxy.network",
+    auth_token="your-api-token",
+    notification_ttl_seconds=3600,
+)
+
+with init_noxy_client(config) as client:
+    # Send a push notification to a wallet address
+    results = client.send_push(
+        "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
+        {"title": "New message", "body": "You have a new notification", "data": {"action": "open_chat", "id": "123"}},
+    )
+
+    # Check quota usage
+    quota = client.get_quota()
+    print(f"{quota.quota_remaining} remaining")
+```
+
+## Configuration
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `endpoint` | `str` | Yes | Noxy relay gRPC endpoint (e.g. `https://relay.noxy.network`). Scheme is stripped; TLS is used by default. |
+| `auth_token` | `str` | Yes | Bearer token for relay authentication. Sent in the `Authorization` header on every request. |
+| `notification_ttl_seconds` | `int` | Yes | Time-to-live for notifications in seconds. |
+
+## API Reference
+
+### `init_noxy_client(config: NoxyConfig) -> NoxyPushClient`
+
+Initializes the SDK client. Normalizes the endpoint and establishes the gRPC connection.
+
+### `NoxyPushClient`
+
+#### `send_push(identity_address, push_notification) -> List[NoxyPushResponse]`
+
+Sends a push notification to all devices registered for the given Web3 identity address.
+
+- **`identity_address`**: EVM address in `0x` format (e.g. `0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1`)
+- **`push_notification`**: Any JSON-serializable object (e.g. `dict`). Encrypted before transmission.
+- **Returns**: List of `NoxyPushResponse` per device, with `status` and `request_id`.
+
+#### `get_quota() -> NoxyGetQuotaResponse`
+
+Returns quota usage for your application.
+
+- **Returns**: `NoxyGetQuotaResponse` with `request_id`, `app_name`, `quota_total`, `quota_remaining`, `status`.
+
+### Types
+
+- **`NoxyPushDeliveryStatus`**: `DELIVERED` (0) | `QUEUED` (1) | `NO_DEVICES` (2) | `REJECTED` (3) | `ERROR` (4)
+- **`NoxyQuotaStatus`**: `QUOTA_ACTIVE` (0) | `QUOTA_SUSPENDED` (1) | `QUOTA_DELETED` (2)
+
+## Encryption Details
+
+1. **Key encapsulation**: For each device, the SDK encapsulates a shared secret using the device's Kyber768 post-quantum public key (`pq_public_key`).
+2. **Key derivation**: The shared secret is expanded via HKDF-SHA256 to a 256-bit AES key.
+3. **Payload encryption**: The notification payload (JSON) is encrypted with AES-256-GCM. The ciphertext includes the GCM auth tag appended for integrity verification.
+4. **Transmission**: Only `kyber_ct`, `nonce`, and `ciphertext` are sent to the relay. The relay cannot decrypt; only the target device (with its secret key) can decrypt.
+
+## Building from source
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+pip install -e .
+
+# Regenerate proto (if proto file changes)
+python -m grpc_tools.protoc -I proto --python_out=noxy/grpc --grpc_python_out=noxy/grpc proto/noxy.proto
+# Fix import in noxy/grpc/noxy_pb2_grpc.py: change "import noxy_pb2" to "from . import noxy_pb2"
+```
+
+## 📄 License
+
+MIT

noxy_sdk-1.0.0/README.md

@@ -0,0 +1,120 @@
+# 📦 @noxy-network/python-sdk
+
+Backend SDK for Python servers to integrate with the [Noxy](https://noxy.network) push notification network. Send encrypted push notifications to Web3 wallet addresses via the Noxy relay infrastructure.
+
+## Overview
+
+This SDK enables server-side applications to:
+
+- **Send push notifications** to users by their Web3 wallet address (EVM `0x` format)
+- **Query quota usage** for your application's relay allocation
+- **Resolve identity devices** to deliver notifications to all registered devices
+
+Communication with the Noxy relay is performed over **gRPC** using Protocol Buffers. All notifications are **encrypted end-to-end** on the backend before transmission; decryption occurs only on the recipient's Noxy device. The SDK uses **post-quantum encryption** (Kyber768) to protect payloads against future quantum attacks.
+
+## Architecture
+
+```
+┌─────────────────┐     gRPC (TLS)      ┌─────────────────┐     E2E Encrypted     ┌─────────────────┐
+│  Your Backend   │ ◄─────────────────► │  Noxy Relay     │ ◄──────────────────► │  Noxy Device    │
+│  (this SDK)     │   PushNotification  │                 │   Ciphertext only    │  (decrypts)      │
+│                 │   GetQuota          │                 │                      │                 │
+│                 │   GetIdentityDevices│                 │                      │                 │
+└─────────────────┘                     └─────────────────┘                      └─────────────────┘
+```
+
+- **Encryption**: Kyber768 (post-quantum KEM) + AES-256-GCM. Each notification is encrypted per-device using the device's post-quantum public key.
+- **Transport**: gRPC over TLS with Bearer token authentication.
+- **Relay**: The Noxy relay forwards ciphertext only; it cannot decrypt notification payloads.
+
+## Requirements
+
+- Python **>= 3.10**
+- C compiler (for kybercffi)
+
+## 🚀 Installation
+
+```bash
+pip install noxy-sdk
+```
+
+## 🛠 Quick Start
+
+```python
+from noxy import NoxyConfig, init_noxy_client
+
+config = NoxyConfig(
+    endpoint="https://relay.noxy.network",
+    auth_token="your-api-token",
+    notification_ttl_seconds=3600,
+)
+
+with init_noxy_client(config) as client:
+    # Send a push notification to a wallet address
+    results = client.send_push(
+        "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
+        {"title": "New message", "body": "You have a new notification", "data": {"action": "open_chat", "id": "123"}},
+    )
+
+    # Check quota usage
+    quota = client.get_quota()
+    print(f"{quota.quota_remaining} remaining")
+```
+
+## Configuration
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `endpoint` | `str` | Yes | Noxy relay gRPC endpoint (e.g. `https://relay.noxy.network`). Scheme is stripped; TLS is used by default. |
+| `auth_token` | `str` | Yes | Bearer token for relay authentication. Sent in the `Authorization` header on every request. |
+| `notification_ttl_seconds` | `int` | Yes | Time-to-live for notifications in seconds. |
+
+## API Reference
+
+### `init_noxy_client(config: NoxyConfig) -> NoxyPushClient`
+
+Initializes the SDK client. Normalizes the endpoint and establishes the gRPC connection.
+
+### `NoxyPushClient`
+
+#### `send_push(identity_address, push_notification) -> List[NoxyPushResponse]`
+
+Sends a push notification to all devices registered for the given Web3 identity address.
+
+- **`identity_address`**: EVM address in `0x` format (e.g. `0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1`)
+- **`push_notification`**: Any JSON-serializable object (e.g. `dict`). Encrypted before transmission.
+- **Returns**: List of `NoxyPushResponse` per device, with `status` and `request_id`.
+
+#### `get_quota() -> NoxyGetQuotaResponse`
+
+Returns quota usage for your application.
+
+- **Returns**: `NoxyGetQuotaResponse` with `request_id`, `app_name`, `quota_total`, `quota_remaining`, `status`.
+
+### Types
+
+- **`NoxyPushDeliveryStatus`**: `DELIVERED` (0) | `QUEUED` (1) | `NO_DEVICES` (2) | `REJECTED` (3) | `ERROR` (4)
+- **`NoxyQuotaStatus`**: `QUOTA_ACTIVE` (0) | `QUOTA_SUSPENDED` (1) | `QUOTA_DELETED` (2)
+
+## Encryption Details
+
+1. **Key encapsulation**: For each device, the SDK encapsulates a shared secret using the device's Kyber768 post-quantum public key (`pq_public_key`).
+2. **Key derivation**: The shared secret is expanded via HKDF-SHA256 to a 256-bit AES key.
+3. **Payload encryption**: The notification payload (JSON) is encrypted with AES-256-GCM. The ciphertext includes the GCM auth tag appended for integrity verification.
+4. **Transmission**: Only `kyber_ct`, `nonce`, and `ciphertext` are sent to the relay. The relay cannot decrypt; only the target device (with its secret key) can decrypt.
+
+## Building from source
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+pip install -e .
+
+# Regenerate proto (if proto file changes)
+python -m grpc_tools.protoc -I proto --python_out=noxy/grpc --grpc_python_out=noxy/grpc proto/noxy.proto
+# Fix import in noxy/grpc/noxy_pb2_grpc.py: change "import noxy_pb2" to "from . import noxy_pb2"
+```
+
+## 📄 License
+
+MIT

noxy_sdk-1.0.0/noxy/__init__.py

@@ -0,0 +1,42 @@
+"""Noxy SDK - Backend SDK for Python servers to integrate with the Noxy push notification network.
+
+Send encrypted push notifications to Web3 wallet addresses via the Noxy relay.
+"""
+
+import re
+from noxy.client import NoxyPushClient
+from noxy.config import NoxyConfig
+from noxy.types import (
+    NoxyGetQuotaResponse,
+    NoxyIdentityDevice,
+    NoxyPushDeliveryStatus,
+    NoxyPushResponse,
+    NoxyQuotaStatus,
+)
+
+
+def init_noxy_client(config: NoxyConfig) -> NoxyPushClient:
+    """Initialize the Noxy client.
+
+    Normalizes the endpoint (strips https:// or http://) and establishes the gRPC connection.
+    """
+    endpoint = re.sub(r"^https?://", "", config.endpoint)
+    endpoint = endpoint.rstrip("/")
+    normalized_config = NoxyConfig(
+        endpoint=endpoint,
+        auth_token=config.auth_token,
+        notification_ttl_seconds=config.notification_ttl_seconds,
+    )
+    return NoxyPushClient(normalized_config)
+
+
+__all__ = [
+    "init_noxy_client",
+    "NoxyPushClient",
+    "NoxyConfig",
+    "NoxyPushResponse",
+    "NoxyPushDeliveryStatus",
+    "NoxyGetQuotaResponse",
+    "NoxyQuotaStatus",
+    "NoxyIdentityDevice",
+]

noxy_sdk-1.0.0/noxy/client.py

@@ -0,0 +1,55 @@
+"""Noxy push client."""
+
+from typing import Any, List
+
+from noxy.config import NoxyConfig
+from noxy.kyber_provider import KyberProvider
+from noxy.services.identity import IdentityService
+from noxy.services.push import PushService
+from noxy.services.quota import QuotaService
+from noxy.transport import create_client
+from noxy.types import NoxyGetQuotaResponse, NoxyPushResponse
+
+
+class NoxyPushClient:
+    """Main SDK client for sending push notifications."""
+
+    def __init__(self, config: NoxyConfig) -> None:
+        self._config = config
+        self._stub, self._channel = create_client(config.endpoint)
+        self._identity = IdentityService()
+        self._push = PushService(KyberProvider())
+        self._quota = QuotaService()
+
+    def send_push(
+        self,
+        identity_address: str,
+        push_notification: Any,
+    ) -> List[NoxyPushResponse]:
+        """Send a push notification to all devices registered for the given Web3 identity address."""
+        devices = self._identity.get_devices(
+            self._stub,
+            self._config.auth_token,
+            identity_address,
+        )
+        return self._push.send(
+            self._stub,
+            self._config.auth_token,
+            devices,
+            push_notification,
+            self._config.notification_ttl_seconds,
+        )
+
+    def get_quota(self) -> NoxyGetQuotaResponse:
+        """Return quota usage for your application."""
+        return self._quota.get(self._stub, self._config.auth_token)
+
+    def close(self) -> None:
+        """Close the gRPC channel."""
+        self._channel.close()
+
+    def __enter__(self) -> "NoxyPushClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

noxy_sdk-1.0.0/noxy/config.py

@@ -0,0 +1,16 @@
+"""Configuration for the Noxy SDK client."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class NoxyConfig:
+    """Configuration for the Noxy SDK client."""
+
+    # Noxy relay gRPC endpoint (e.g. "https://relay.noxy.network:443").
+    # Scheme is stripped; TLS is used by default.
+    endpoint: str
+    # Bearer token for relay authentication.
+    auth_token: str
+    # Time-to-live for notifications in seconds.
+    notification_ttl_seconds: int

noxy_sdk-1.0.0/noxy/crypto.py

@@ -0,0 +1,28 @@
+"""AES-256-GCM encryption with HKDF key derivation."""
+
+import os
+from typing import Tuple
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+
+def encrypt(shared_secret: bytes, plaintext: bytes) -> Tuple[bytes, bytes]:
+    """Encrypt plaintext with AES-256-GCM using a key derived from the shared secret via HKDF-SHA256.
+
+    Returns (ciphertext_with_auth_tag, nonce). The auth tag (16 bytes) is appended to ciphertext.
+    """
+    hkdf = HKDF(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=None,
+        info=b"",
+    )
+    key = hkdf.derive(shared_secret)
+
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(key)
+    ciphertext = aesgcm.encrypt(nonce, plaintext, None)
+
+    return ciphertext, nonce

noxy_sdk-1.0.0/noxy/grpc/noxy_pb2.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: noxy.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'noxy.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nnoxy.proto\x12\tnoxy.push\"\x91\x01\n\x17PushNotificationRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x12\n\nciphertext\x18\x02 \x01(\x0c\x12\x13\n\x0bttl_seconds\x18\x03 \x01(\r\x12\x18\n\x10target_device_id\x18\x04 \x01(\t\x12\x10\n\x08kyber_ct\x18\x05 \x01(\x0c\x12\r\n\x05nonce\x18\x06 \x01(\x0c\"M\n\x0cPushResponse\x12)\n\x06status\x18\x01 \x01(\x0e\x32\x19.noxy.push.DeliveryStatus\x12\x12\n\nrequest_id\x18\x02 \x01(\t\"%\n\x0fGetQuotaRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\"\x8e\x01\n\x10GetQuotaResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x10\n\x08\x61pp_name\x18\x02 \x01(\t\x12\x13\n\x0bquota_total\x18\x03 \x01(\x04\x12\x17\n\x0fquota_remaining\x18\x04 \x01(\x04\x12&\n\x06status\x18\x05 \x01(\x0e\x32\x16.noxy.push.QuotaStatus\"D\n\x19GetIdentityDevicesRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x13\n\x0bidentity_id\x18\x02 \x01(\t\"N\n\x0eIdentityDevice\x12\x11\n\tdevice_id\x18\x01 \x01(\t\x12\x12\n\npublic_key\x18\x02 \x01(\x0c\x12\x15\n\rpq_public_key\x18\x03 \x01(\x0c\"\\\n\x1aGetIdentityDevicesResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12*\n\x07\x64\x65vices\x18\x02 \x03(\x0b\x32\x19.noxy.push.IdentityDevice*T\n\x0e\x44\x65liveryStatus\x12\r\n\tDELIVERED\x10\x00\x12\n\n\x06QUEUED\x10\x01\x12\x0e\n\nNO_DEVICES\x10\x02\x12\x0c\n\x08REJECTED\x10\x03\x12\t\n\x05\x45RROR\x10\x04*G\n\x0bQuotaStatus\x12\x10\n\x0cQUOTA_ACTIVE\x10\x00\x12\x13\n\x0fQUOTA_SUSPENDED\x10\x01\x12\x11\n\rQUOTA_DELETED\x10\x02\x32\x86\x02\n\x0bPushService\x12O\n\x10PushNotification\x12\".noxy.push.PushNotificationRequest\x1a\x17.noxy.push.PushResponse\x12\x43\n\x08GetQuota\x12\x1a.noxy.push.GetQuotaRequest\x1a\x1b.noxy.push.GetQuotaResponse\x12\x61\n\x12GetIdentityDevices\x12$.noxy.push.GetIdentityDevicesRequest\x1a%.noxy.push.GetIdentityDevicesResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'noxy_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_DELIVERYSTATUS']._serialized_start=680
+  _globals['_DELIVERYSTATUS']._serialized_end=764
+  _globals['_QUOTASTATUS']._serialized_start=766
+  _globals['_QUOTASTATUS']._serialized_end=837
+  _globals['_PUSHNOTIFICATIONREQUEST']._serialized_start=26
+  _globals['_PUSHNOTIFICATIONREQUEST']._serialized_end=171
+  _globals['_PUSHRESPONSE']._serialized_start=173
+  _globals['_PUSHRESPONSE']._serialized_end=250
+  _globals['_GETQUOTAREQUEST']._serialized_start=252
+  _globals['_GETQUOTAREQUEST']._serialized_end=289
+  _globals['_GETQUOTARESPONSE']._serialized_start=292
+  _globals['_GETQUOTARESPONSE']._serialized_end=434
+  _globals['_GETIDENTITYDEVICESREQUEST']._serialized_start=436
+  _globals['_GETIDENTITYDEVICESREQUEST']._serialized_end=504
+  _globals['_IDENTITYDEVICE']._serialized_start=506
+  _globals['_IDENTITYDEVICE']._serialized_end=584
+  _globals['_GETIDENTITYDEVICESRESPONSE']._serialized_start=586
+  _globals['_GETIDENTITYDEVICESRESPONSE']._serialized_end=678
+  _globals['_PUSHSERVICE']._serialized_start=840
+  _globals['_PUSHSERVICE']._serialized_end=1102
+# @@protoc_insertion_point(module_scope)

noxy_sdk-1.0.0/noxy/grpc/noxy_pb2_grpc.py

@@ -0,0 +1,183 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import noxy_pb2 as noxy__pb2
+
+GRPC_GENERATED_VERSION = '1.78.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in noxy_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class PushServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.PushNotification = channel.unary_unary(
+                '/noxy.push.PushService/PushNotification',
+                request_serializer=noxy__pb2.PushNotificationRequest.SerializeToString,
+                response_deserializer=noxy__pb2.PushResponse.FromString,
+                _registered_method=True)
+        self.GetQuota = channel.unary_unary(
+                '/noxy.push.PushService/GetQuota',
+                request_serializer=noxy__pb2.GetQuotaRequest.SerializeToString,
+                response_deserializer=noxy__pb2.GetQuotaResponse.FromString,
+                _registered_method=True)
+        self.GetIdentityDevices = channel.unary_unary(
+                '/noxy.push.PushService/GetIdentityDevices',
+                request_serializer=noxy__pb2.GetIdentityDevicesRequest.SerializeToString,
+                response_deserializer=noxy__pb2.GetIdentityDevicesResponse.FromString,
+                _registered_method=True)
+
+
+class PushServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def PushNotification(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetQuota(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetIdentityDevices(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_PushServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'PushNotification': grpc.unary_unary_rpc_method_handler(
+                    servicer.PushNotification,
+                    request_deserializer=noxy__pb2.PushNotificationRequest.FromString,
+                    response_serializer=noxy__pb2.PushResponse.SerializeToString,
+            ),
+            'GetQuota': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetQuota,
+                    request_deserializer=noxy__pb2.GetQuotaRequest.FromString,
+                    response_serializer=noxy__pb2.GetQuotaResponse.SerializeToString,
+            ),
+            'GetIdentityDevices': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetIdentityDevices,
+                    request_deserializer=noxy__pb2.GetIdentityDevicesRequest.FromString,
+                    response_serializer=noxy__pb2.GetIdentityDevicesResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'noxy.push.PushService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('noxy.push.PushService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class PushService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def PushNotification(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/noxy.push.PushService/PushNotification',
+            noxy__pb2.PushNotificationRequest.SerializeToString,
+            noxy__pb2.PushResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetQuota(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/noxy.push.PushService/GetQuota',
+            noxy__pb2.GetQuotaRequest.SerializeToString,
+            noxy__pb2.GetQuotaResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetIdentityDevices(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/noxy.push.PushService/GetIdentityDevices',
+            noxy__pb2.GetIdentityDevicesRequest.SerializeToString,
+            noxy__pb2.GetIdentityDevicesResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

noxy_sdk-1.0.0/noxy/kyber_provider.py

@@ -0,0 +1,19 @@
+"""Kyber768 post-quantum key encapsulation for notification encryption."""
+
+from typing import Tuple
+
+import kybercffi
+
+
+class KyberProvider:
+    """Kyber768 provider for encapsulating shared secrets with device public keys."""
+
+    def __init__(self) -> None:
+        self._kyber = kybercffi.Kyber768()
+
+    def encapsulate(self, public_key: bytes) -> Tuple[bytes, bytes]:
+        """Encapsulate a shared secret using the device's post-quantum public key.
+
+        Returns (kyber_ciphertext, shared_secret). Ciphertext is 1088 bytes, shared secret is 32 bytes.
+        """
+        return self._kyber.encapsulate(public_key)

noxy_sdk-1.0.0/noxy/retries.py

@@ -0,0 +1,64 @@
+"""Retry logic for transient network errors."""
+
+import asyncio
+import time
+from typing import Callable, TypeVar
+
+import grpc
+
+# gRPC status codes that indicate retryable errors
+RETRYABLE_CODES = frozenset({
+    grpc.StatusCode.UNKNOWN,
+    grpc.StatusCode.DEADLINE_EXCEEDED,
+    grpc.StatusCode.RESOURCE_EXHAUSTED,
+    grpc.StatusCode.UNAVAILABLE,
+})
+
+
+def is_retryable(err: Exception) -> bool:
+    """Check if an error is retryable (network/unavailable)."""
+    if isinstance(err, grpc.RpcError):
+        return err.code() in RETRYABLE_CODES
+    return False
+
+
+T = TypeVar("T")
+
+
+async def with_retry_async(
+    fn: Callable[[], T],
+    retries: int = 3,
+) -> T:
+    """Execute an async callable with retries on retryable errors."""
+    last_err = None
+    for attempt in range(retries):
+        try:
+            result = fn()
+            if asyncio.iscoroutine(result):
+                return await result
+            return result
+        except Exception as e:
+            last_err = e
+            if attempt < retries - 1 and is_retryable(e):
+                await asyncio.sleep((2**attempt) * 0.1)
+            else:
+                raise
+    raise last_err
+
+
+def with_retry_sync(
+    fn: Callable[[], T],
+    retries: int = 3,
+) -> T:
+    """Execute a sync callable with retries on retryable errors."""
+    last_err = None
+    for attempt in range(retries):
+        try:
+            return fn()
+        except Exception as e:
+            last_err = e
+            if attempt < retries - 1 and is_retryable(e):
+                time.sleep((2**attempt) * 0.1)
+            else:
+                raise
+    raise last_err

noxy_sdk-1.0.0/noxy/services/__init__.py

@@ -0,0 +1,7 @@
+"""Noxy services."""
+
+from noxy.services.identity import IdentityService
+from noxy.services.quota import QuotaService
+from noxy.services.push import PushService
+
+__all__ = ["IdentityService", "QuotaService", "PushService"]

noxy_sdk-1.0.0/noxy/services/identity.py

@@ -0,0 +1,34 @@
+"""Identity service for fetching devices."""
+
+import uuid
+
+from noxy.grpc import noxy_pb2
+from noxy.transport import auth_metadata
+from noxy.types import NoxyIdentityDevice
+
+
+class IdentityService:
+    """Fetches identity devices from the relay."""
+
+    def get_devices(
+        self,
+        stub,
+        auth_token: str,
+        identity_id: str,
+    ) -> list[NoxyIdentityDevice]:
+        """Return all devices registered for the given identity address."""
+        req = noxy_pb2.GetIdentityDevicesRequest(
+            request_id=str(uuid.uuid4()),
+            identity_id=identity_id,
+        )
+        metadata = auth_metadata(auth_token)
+        resp = stub.GetIdentityDevices(req, metadata=metadata)
+
+        return [
+            NoxyIdentityDevice(
+                device_id=d.device_id,
+                public_key=bytes(d.public_key),
+                pq_public_key=bytes(d.pq_public_key),
+            )
+            for d in resp.devices
+        ]

noxy_sdk-1.0.0/noxy/services/push.py

@@ -0,0 +1,87 @@
+"""Push service for sending encrypted notifications."""
+
+import json
+import uuid
+from typing import Any, List
+
+from noxy.crypto import encrypt
+from noxy.grpc import noxy_pb2
+from noxy.kyber_provider import KyberProvider
+from noxy.retries import with_retry_sync
+from noxy.transport import auth_metadata
+from noxy.types import NoxyIdentityDevice, NoxyPushDeliveryStatus, NoxyPushResponse
+
+
+class PushService:
+    """Sends encrypted push notifications."""
+
+    def __init__(self, kyber_provider: KyberProvider) -> None:
+        self._kyber = kyber_provider
+
+    def _encrypt_notification(
+        self,
+        device_pq_public_key: bytes,
+        plaintext: bytes,
+    ) -> tuple[bytes, bytes, bytes]:
+        """Encrypt notification for a device. Returns (kyber_ct, nonce, ciphertext)."""
+        kyber_ct, shared_secret = self._kyber.encapsulate(device_pq_public_key)
+        ciphertext, nonce = encrypt(shared_secret, plaintext)
+        return kyber_ct, nonce, ciphertext
+
+    def _send_to_network(
+        self,
+        stub,
+        auth_token: str,
+        ciphertext: bytes,
+        ttl_seconds: int,
+        target_device_id: str,
+        kyber_ct: bytes,
+        nonce: bytes,
+    ) -> NoxyPushResponse:
+        """Send encrypted payload to the relay with retries."""
+        def _do_send() -> NoxyPushResponse:
+            req = noxy_pb2.PushNotificationRequest(
+                request_id=str(uuid.uuid4()),
+                ciphertext=ciphertext,
+                ttl_seconds=ttl_seconds,
+                target_device_id=target_device_id,
+                kyber_ct=kyber_ct,
+                nonce=nonce,
+            )
+            metadata = auth_metadata(auth_token)
+            resp = stub.PushNotification(req, metadata=metadata)
+            return NoxyPushResponse(
+                status=NoxyPushDeliveryStatus(resp.status),
+                request_id=resp.request_id,
+            )
+
+        return with_retry_sync(_do_send, retries=3)
+
+    def send(
+        self,
+        stub,
+        auth_token: str,
+        devices: List[NoxyIdentityDevice],
+        push_notification: Any,
+        ttl_seconds: int,
+    ) -> List[NoxyPushResponse]:
+        """Send a push notification to all devices, encrypting per device."""
+        plaintext = json.dumps(push_notification, default=str).encode("utf-8")
+        results: List[NoxyPushResponse] = []
+
+        for device in devices:
+            kyber_ct, nonce, ciphertext = self._encrypt_notification(
+                device.pq_public_key, plaintext
+            )
+            resp = self._send_to_network(
+                stub,
+                auth_token,
+                ciphertext,
+                ttl_seconds,
+                device.device_id,
+                kyber_ct,
+                nonce,
+            )
+            results.append(resp)
+
+        return results

noxy_sdk-1.0.0/noxy/services/quota.py

@@ -0,0 +1,25 @@
+"""Quota service for fetching usage."""
+
+import uuid
+
+from noxy.grpc import noxy_pb2
+from noxy.transport import auth_metadata
+from noxy.types import NoxyGetQuotaResponse, NoxyQuotaStatus
+
+
+class QuotaService:
+    """Fetches quota usage from the relay."""
+
+    def get(self, stub, auth_token: str) -> NoxyGetQuotaResponse:
+        """Return quota usage for the application."""
+        req = noxy_pb2.GetQuotaRequest(request_id=str(uuid.uuid4()))
+        metadata = auth_metadata(auth_token)
+        resp = stub.GetQuota(req, metadata=metadata)
+
+        return NoxyGetQuotaResponse(
+            request_id=resp.request_id,
+            app_name=resp.app_name,
+            quota_total=resp.quota_total,
+            quota_remaining=resp.quota_remaining,
+            status=NoxyQuotaStatus(resp.status),
+        )

noxy_sdk-1.0.0/noxy/transport.py

@@ -0,0 +1,32 @@
+"""gRPC transport layer for Noxy relay communication."""
+
+import re
+from typing import Tuple
+
+import grpc
+
+from noxy.grpc import noxy_pb2, noxy_pb2_grpc
+
+
+def _normalize_endpoint(endpoint: str) -> str:
+    """Strip https:// or http:// and trailing slashes."""
+    s = re.sub(r"^https?://", "", endpoint)
+    return s.rstrip("/")
+
+
+def create_channel(endpoint: str) -> grpc.Channel:
+    """Create a secure gRPC channel to the Noxy relay."""
+    addr = _normalize_endpoint(endpoint)
+    return grpc.secure_channel(addr, grpc.ssl_channel_credentials())
+
+
+def create_client(endpoint: str) -> Tuple[noxy_pb2_grpc.PushServiceStub, grpc.Channel]:
+    """Create a PushService stub and channel."""
+    channel = create_channel(endpoint)
+    stub = noxy_pb2_grpc.PushServiceStub(channel)
+    return stub, channel
+
+
+def auth_metadata(auth_token: str) -> list[tuple[str, str]]:
+    """Return metadata with Bearer token for gRPC calls."""
+    return [("authorization", f"Bearer {auth_token}")]

noxy_sdk-1.0.0/noxy/types.py

@@ -0,0 +1,55 @@
+"""Type definitions matching the proto and SDK API."""
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import List
+
+
+# EVM wallet address in 0x format
+NoxyIdentityAddress = str
+
+
+class NoxyPushDeliveryStatus(IntEnum):
+    """Delivery status for a push notification."""
+
+    DELIVERED = 0
+    QUEUED = 1
+    NO_DEVICES = 2
+    REJECTED = 3
+    ERROR = 4
+
+
+@dataclass
+class NoxyPushResponse:
+    """Response for a push notification send."""
+
+    status: NoxyPushDeliveryStatus
+    request_id: str
+
+
+class NoxyQuotaStatus(IntEnum):
+    """Quota status for the application."""
+
+    QUOTA_ACTIVE = 0
+    QUOTA_SUSPENDED = 1
+    QUOTA_DELETED = 2
+
+
+@dataclass
+class NoxyGetQuotaResponse:
+    """Response for a quota query."""
+
+    request_id: str
+    app_name: str
+    quota_total: int
+    quota_remaining: int
+    status: NoxyQuotaStatus
+
+
+@dataclass
+class NoxyIdentityDevice:
+    """Identity device with keys for encryption."""
+
+    device_id: str
+    public_key: bytes
+    pq_public_key: bytes

noxy_sdk-1.0.0/noxy_sdk.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: noxy-sdk
+Version: 1.0.0
+Summary: Backend SDK for Python servers to integrate with the Noxy push notification network
+Author: Noxy Network
+License: MIT
+Keywords: noxy,push-notifications,web3,post-quantum,grpc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio>=1.60.0
+Requires-Dist: grpcio-tools>=1.60.0
+Requires-Dist: protobuf>=4.25.0
+Requires-Dist: kybercffi>=1.0.0
+Requires-Dist: cryptography>=42.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# 📦 @noxy-network/python-sdk
+
+Backend SDK for Python servers to integrate with the [Noxy](https://noxy.network) push notification network. Send encrypted push notifications to Web3 wallet addresses via the Noxy relay infrastructure.
+
+## Overview
+
+This SDK enables server-side applications to:
+
+- **Send push notifications** to users by their Web3 wallet address (EVM `0x` format)
+- **Query quota usage** for your application's relay allocation
+- **Resolve identity devices** to deliver notifications to all registered devices
+
+Communication with the Noxy relay is performed over **gRPC** using Protocol Buffers. All notifications are **encrypted end-to-end** on the backend before transmission; decryption occurs only on the recipient's Noxy device. The SDK uses **post-quantum encryption** (Kyber768) to protect payloads against future quantum attacks.
+
+## Architecture
+
+```
+┌─────────────────┐     gRPC (TLS)      ┌─────────────────┐     E2E Encrypted     ┌─────────────────┐
+│  Your Backend   │ ◄─────────────────► │  Noxy Relay     │ ◄──────────────────► │  Noxy Device    │
+│  (this SDK)     │   PushNotification  │                 │   Ciphertext only    │  (decrypts)      │
+│                 │   GetQuota          │                 │                      │                 │
+│                 │   GetIdentityDevices│                 │                      │                 │
+└─────────────────┘                     └─────────────────┘                      └─────────────────┘
+```
+
+- **Encryption**: Kyber768 (post-quantum KEM) + AES-256-GCM. Each notification is encrypted per-device using the device's post-quantum public key.
+- **Transport**: gRPC over TLS with Bearer token authentication.
+- **Relay**: The Noxy relay forwards ciphertext only; it cannot decrypt notification payloads.
+
+## Requirements
+
+- Python **>= 3.10**
+- C compiler (for kybercffi)
+
+## 🚀 Installation
+
+```bash
+pip install noxy-sdk
+```
+
+## 🛠 Quick Start
+
+```python
+from noxy import NoxyConfig, init_noxy_client
+
+config = NoxyConfig(
+    endpoint="https://relay.noxy.network",
+    auth_token="your-api-token",
+    notification_ttl_seconds=3600,
+)
+
+with init_noxy_client(config) as client:
+    # Send a push notification to a wallet address
+    results = client.send_push(
+        "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
+        {"title": "New message", "body": "You have a new notification", "data": {"action": "open_chat", "id": "123"}},
+    )
+
+    # Check quota usage
+    quota = client.get_quota()
+    print(f"{quota.quota_remaining} remaining")
+```
+
+## Configuration
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `endpoint` | `str` | Yes | Noxy relay gRPC endpoint (e.g. `https://relay.noxy.network`). Scheme is stripped; TLS is used by default. |
+| `auth_token` | `str` | Yes | Bearer token for relay authentication. Sent in the `Authorization` header on every request. |
+| `notification_ttl_seconds` | `int` | Yes | Time-to-live for notifications in seconds. |
+
+## API Reference
+
+### `init_noxy_client(config: NoxyConfig) -> NoxyPushClient`
+
+Initializes the SDK client. Normalizes the endpoint and establishes the gRPC connection.
+
+### `NoxyPushClient`
+
+#### `send_push(identity_address, push_notification) -> List[NoxyPushResponse]`
+
+Sends a push notification to all devices registered for the given Web3 identity address.
+
+- **`identity_address`**: EVM address in `0x` format (e.g. `0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1`)
+- **`push_notification`**: Any JSON-serializable object (e.g. `dict`). Encrypted before transmission.
+- **Returns**: List of `NoxyPushResponse` per device, with `status` and `request_id`.
+
+#### `get_quota() -> NoxyGetQuotaResponse`
+
+Returns quota usage for your application.
+
+- **Returns**: `NoxyGetQuotaResponse` with `request_id`, `app_name`, `quota_total`, `quota_remaining`, `status`.
+
+### Types
+
+- **`NoxyPushDeliveryStatus`**: `DELIVERED` (0) | `QUEUED` (1) | `NO_DEVICES` (2) | `REJECTED` (3) | `ERROR` (4)
+- **`NoxyQuotaStatus`**: `QUOTA_ACTIVE` (0) | `QUOTA_SUSPENDED` (1) | `QUOTA_DELETED` (2)
+
+## Encryption Details
+
+1. **Key encapsulation**: For each device, the SDK encapsulates a shared secret using the device's Kyber768 post-quantum public key (`pq_public_key`).
+2. **Key derivation**: The shared secret is expanded via HKDF-SHA256 to a 256-bit AES key.
+3. **Payload encryption**: The notification payload (JSON) is encrypted with AES-256-GCM. The ciphertext includes the GCM auth tag appended for integrity verification.
+4. **Transmission**: Only `kyber_ct`, `nonce`, and `ciphertext` are sent to the relay. The relay cannot decrypt; only the target device (with its secret key) can decrypt.
+
+## Building from source
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+pip install -e .
+
+# Regenerate proto (if proto file changes)
+python -m grpc_tools.protoc -I proto --python_out=noxy/grpc --grpc_python_out=noxy/grpc proto/noxy.proto
+# Fix import in noxy/grpc/noxy_pb2_grpc.py: change "import noxy_pb2" to "from . import noxy_pb2"
+```
+
+## 📄 License
+
+MIT

noxy_sdk-1.0.0/noxy_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+noxy/__init__.py
+noxy/client.py
+noxy/config.py
+noxy/crypto.py
+noxy/kyber_provider.py
+noxy/retries.py
+noxy/transport.py
+noxy/types.py
+noxy/grpc/__init__.py
+noxy/grpc/noxy_pb2.py
+noxy/grpc/noxy_pb2_grpc.py
+noxy/services/__init__.py
+noxy/services/identity.py
+noxy/services/push.py
+noxy/services/quota.py
+noxy_sdk.egg-info/PKG-INFO
+noxy_sdk.egg-info/SOURCES.txt
+noxy_sdk.egg-info/dependency_links.txt
+noxy_sdk.egg-info/requires.txt
+noxy_sdk.egg-info/top_level.txt

noxy_sdk-1.0.0/noxy_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

noxy_sdk-1.0.0/noxy_sdk.egg-info/requires.txt

@@ -0,0 +1,9 @@
+grpcio>=1.60.0
+grpcio-tools>=1.60.0
+protobuf>=4.25.0
+kybercffi>=1.0.0
+cryptography>=42.0.0
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21.0

noxy_sdk-1.0.0/noxy_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+noxy

noxy_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "noxy-sdk"
+version = "1.0.0"
+description = "Backend SDK for Python servers to integrate with the Noxy push notification network"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Noxy Network" }]
+keywords = ["noxy", "push-notifications", "web3", "post-quantum", "grpc"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security :: Cryptography",
+]
+
+dependencies = [
+    "grpcio>=1.60.0",
+    "grpcio-tools>=1.60.0",
+    "protobuf>=4.25.0",
+    "kybercffi>=1.0.0",
+    "cryptography>=42.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["noxy*"]

noxy_sdk-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+