doublezero-serviceability 0.0.2__tar.gz

doublezero_serviceability-0.0.2/.gitignore

@@ -0,0 +1,35 @@
+*.pdb
+.DS_STORE
+**/*.swp
+**/*.rs.bk
+**/coverage.out
+debug/
+target/
+logs/
+test-ledger/
+
+**/bin/*
+smartcontract/cli/config/*
+controlplane/funder/cmd/funder/funder
+revdist-cli
+
+.idea
+.private
+.vscode/*
+.vscode
+.zed
+.claude/plans/
+.tmp
+.env
+
+dist/
+node_modules/
+__pycache__/
+.pytest_cache/
+.venv/
+
+# Local devnet deployment artifacts.
+dev/.deploy/
+
+# Ignore the directory used for checking out the monitor tool in CI
+/doublezero_monitor/

doublezero_serviceability-0.0.2/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: doublezero-serviceability
+Version: 0.0.2
+Summary: DoubleZero Serviceability SDK
+Requires-Python: >=3.10
+Requires-Dist: borsh-incremental
+Requires-Dist: httpx>=0.27
+Requires-Dist: solana>=0.35
+Requires-Dist: solders>=0.21

doublezero_serviceability-0.0.2/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "doublezero-serviceability"
+version = "0.0.2"
+description = "DoubleZero Serviceability SDK"
+requires-python = ">=3.10"
+dependencies = [
+    "borsh-incremental",
+    "solana>=0.35",
+    "solders>=0.21",
+    "httpx>=0.27",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["serviceability/tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["serviceability"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]
+
+[tool.uv.sources]
+borsh-incremental = { path = "../../borsh-incremental/python", editable = true }

doublezero_serviceability-0.0.2/serviceability/client.py

@@ -0,0 +1,85 @@
+"""RPC client for fetching serviceability program accounts."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from solders.pubkey import Pubkey  # type: ignore[import-untyped]
+from solders.rpc.responses import GetAccountInfoResp  # type: ignore[import-untyped]
+
+from serviceability.config import PROGRAM_IDS, LEDGER_RPC_URLS
+from serviceability.rpc import new_rpc_client
+from serviceability.state import (
+    AccessPass,
+    Contributor,
+    Device,
+    Exchange,
+    GlobalConfig,
+    GlobalState,
+    Link,
+    Location,
+    MulticastGroup,
+    ProgramConfig,
+    User,
+)
+
+
+class SolanaClient(Protocol):
+    def get_account_info(self, pubkey: Pubkey) -> GetAccountInfoResp: ...
+
+
+class ProgramData:
+    """Aggregate of all serviceability program accounts."""
+
+    def __init__(self) -> None:
+        self.global_state: GlobalState | None = None
+        self.global_config: GlobalConfig | None = None
+        self.program_config: ProgramConfig | None = None
+        self.locations: list[Location] = []
+        self.exchanges: list[Exchange] = []
+        self.devices: list[Device] = []
+        self.links: list[Link] = []
+        self.users: list[User] = []
+        self.multicast_groups: list[MulticastGroup] = []
+        self.contributors: list[Contributor] = []
+        self.access_passes: list[AccessPass] = []
+
+
+class Client:
+    """Read-only client for serviceability program accounts."""
+
+    def __init__(
+        self,
+        solana_rpc: SolanaClient,
+        program_id: Pubkey,
+    ) -> None:
+        self._solana_rpc = solana_rpc
+        self._program_id = program_id
+
+    @classmethod
+    def from_env(cls, env: str) -> Client:
+        """Create a client configured for the given environment.
+
+        Args:
+            env: Environment name ("mainnet-beta", "testnet", "devnet", "localnet")
+        """
+        return cls(
+            new_rpc_client(LEDGER_RPC_URLS[env]),
+            Pubkey.from_string(PROGRAM_IDS[env]),
+        )
+
+    @classmethod
+    def mainnet_beta(cls) -> Client:
+        return cls.from_env("mainnet-beta")
+
+    @classmethod
+    def testnet(cls) -> Client:
+        return cls.from_env("testnet")
+
+    @classmethod
+    def devnet(cls) -> Client:
+        return cls.from_env("devnet")
+
+    @classmethod
+    def localnet(cls) -> Client:
+        return cls.from_env("localnet")

doublezero_serviceability-0.0.2/serviceability/config.py

@@ -0,0 +1,15 @@
+"""Network configuration for the serviceability program."""
+
+PROGRAM_IDS = {
+    "mainnet-beta": "ser2VaTMAcYTaauMrTSfSrxBaUDq7BLNs2xfUugTAGv",
+    "testnet": "DZtnuQ839pSaDMFG5q1ad2V95G82S5EC4RrB3Ndw2Heb",
+    "devnet": "GYhQDKuESrasNZGyhMJhGYFtbzNijYhcrN9poSqCQVah",
+    "localnet": "7CTniUa88iJKUHTrCkB4TjAoG6TD7AMivhQeuqN2LPtX",
+}
+
+LEDGER_RPC_URLS = {
+    "mainnet-beta": "https://doublezero-mainnet-beta.rpcpool.com/db336024-e7a8-46b1-80e5-352dd77060ab",
+    "testnet": "https://doublezerolocalnet.rpcpool.com/8a4fd3f4-0977-449f-88c7-63d4b0f10f16",
+    "devnet": "https://doublezerolocalnet.rpcpool.com/8a4fd3f4-0977-449f-88c7-63d4b0f10f16",
+    "localnet": "http://localhost:8899",
+}

doublezero_serviceability-0.0.2/serviceability/pda.py

@@ -0,0 +1,20 @@
+"""PDA derivation for serviceability program accounts."""
+
+from solders.pubkey import Pubkey  # type: ignore[import-untyped]
+
+SEED_PREFIX = b"doublezero"
+SEED_GLOBAL_STATE = b"globalstate"
+SEED_GLOBAL_CONFIG = b"config"
+SEED_PROGRAM_CONFIG = b"programconfig"
+
+
+def derive_global_state_pda(program_id: Pubkey) -> tuple[Pubkey, int]:
+    return Pubkey.find_program_address([SEED_PREFIX, SEED_GLOBAL_STATE], program_id)
+
+
+def derive_global_config_pda(program_id: Pubkey) -> tuple[Pubkey, int]:
+    return Pubkey.find_program_address([SEED_PREFIX, SEED_GLOBAL_CONFIG], program_id)
+
+
+def derive_program_config_pda(program_id: Pubkey) -> tuple[Pubkey, int]:
+    return Pubkey.find_program_address([SEED_PREFIX, SEED_PROGRAM_CONFIG], program_id)

doublezero_serviceability-0.0.2/serviceability/rpc.py

@@ -0,0 +1,48 @@
+"""RPC client helpers with retry on rate limiting."""
+
+import time
+
+import httpx
+from solana.rpc.api import Client as SolanaHTTPClient  # type: ignore[import-untyped]
+
+_DEFAULT_MAX_RETRIES = 5
+
+
+class _RetryTransport(httpx.BaseTransport):
+    """HTTP transport that retries on 429 Too Many Requests."""
+
+    def __init__(
+        self,
+        wrapped: httpx.BaseTransport | None = None,
+        max_retries: int = _DEFAULT_MAX_RETRIES,
+    ) -> None:
+        self._wrapped = wrapped or httpx.HTTPTransport()
+        self._max_retries = max_retries
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        for attempt in range(self._max_retries + 1):
+            response = self._wrapped.handle_request(request)
+            if response.status_code != 429 or attempt >= self._max_retries:
+                return response
+            response.close()
+            time.sleep((attempt + 1) * 2)
+        return response  # unreachable, but satisfies type checker
+
+
+def new_rpc_client(
+    url: str,
+    timeout: float = 30,
+    max_retries: int = _DEFAULT_MAX_RETRIES,
+) -> SolanaHTTPClient:
+    """Create a Solana RPC client with automatic retry on 429 responses."""
+    client = SolanaHTTPClient(url, timeout=timeout)
+    # Replace the underlying httpx session with one using retry transport.
+    transport = _RetryTransport(
+        wrapped=httpx.HTTPTransport(),
+        max_retries=max_retries,
+    )
+    client._provider.session = httpx.Client(
+        timeout=timeout,
+        transport=transport,
+    )
+    return client