walletdna 1.0.0__tar.gz

walletdna-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: walletdna
+Version: 1.0.0
+Summary: Official WalletDNA SDK — wallet screening (allow / review / block), batch screening, and signed webhook verification.
+Author: WalletDNA
+License: MIT
+Project-URL: Homepage, https://walletdna.com/developer
+Project-URL: Documentation, https://walletdna.com/docs/api
+Project-URL: Source, https://github.com/wallet-dna/walletdna
+Keywords: walletdna,wallet,screening,sanctions,ofac,aml,crypto,compliance,webhooks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# walletdna (Python)
+
+Official Python SDK for the [WalletDNA](https://walletdna.com) API — screen any wallet for sanctions and high‑risk exposure, get a clear **allow / review / block** decision, and verify signed webhooks. Standard library only, no dependencies.
+
+API access requires an **Advanced** or **Enterprise** plan. Create an API key at <https://walletdna.com/developer>.
+
+## Install
+
+```sh
+pip install walletdna
+```
+
+Requires Python 3.8+.
+
+## Screen a wallet
+
+```python
+import os
+from walletdna import WalletDNA
+
+wdna = WalletDNA(os.environ["WALLETDNA_API_KEY"])
+
+verdict = wdna.screen("0x722122dF12D4e14e13Ac3b6895a86e84145b6967")
+print(verdict["decision"])  # "allow" | "review" | "block"
+
+if verdict["decision"] == "block":
+    ...  # reject the deposit / withdrawal
+```
+
+### Custom thresholds & auto‑monitoring
+
+```python
+verdict = wdna.screen(
+    address,
+    thresholds={"review": 40, "block": 75},  # map riskScore -> decision (sanctioned always blocks)
+    monitor=True,                              # also watch this wallet and webhook me on changes
+)
+```
+
+### Batch (up to 25 addresses)
+
+```python
+resp = wdna.screen_batch([addr_a, addr_b, addr_c])
+blocked = [r for r in resp["results"] if r.get("decision") == "block"]
+```
+
+## Webhooks
+
+Register an endpoint (the signing secret is returned **once** — store it):
+
+```python
+hook = wdna.create_webhook(
+    "https://api.acme.com/walletdna",
+    events=["wallet.risk_changed", "wallet.sanctioned"],
+)
+secret = hook["secret"]
+```
+
+Verify incoming events with the raw request body and the `WalletDNA-Signature` header (Flask example):
+
+```python
+from flask import Flask, request, abort
+from walletdna import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/walletdna")
+def walletdna_webhook():
+    raw = request.get_data(as_text=True)
+    if not verify_webhook(raw, request.headers.get("WalletDNA-Signature", ""), WDNA_WEBHOOK_SECRET):
+        abort(400)
+    event = request.get_json()
+    # event["type"], event["data"] (a screening verdict + previousScore/label/reportUrl)
+    return "", 200
+```
+
+## Errors
+
+Failed requests raise `WalletDNAError` with `.status`, `.code`, and `.body`. A `429` means you've hit your monthly API limit — add credits in the dashboard.
+
+## Reference
+
+Full OpenAPI spec: <https://walletdna.com/api/openapi> · Docs: <https://walletdna.com/docs/api>

walletdna-1.0.0/README.md

@@ -0,0 +1,83 @@
+# walletdna (Python)
+
+Official Python SDK for the [WalletDNA](https://walletdna.com) API — screen any wallet for sanctions and high‑risk exposure, get a clear **allow / review / block** decision, and verify signed webhooks. Standard library only, no dependencies.
+
+API access requires an **Advanced** or **Enterprise** plan. Create an API key at <https://walletdna.com/developer>.
+
+## Install
+
+```sh
+pip install walletdna
+```
+
+Requires Python 3.8+.
+
+## Screen a wallet
+
+```python
+import os
+from walletdna import WalletDNA
+
+wdna = WalletDNA(os.environ["WALLETDNA_API_KEY"])
+
+verdict = wdna.screen("0x722122dF12D4e14e13Ac3b6895a86e84145b6967")
+print(verdict["decision"])  # "allow" | "review" | "block"
+
+if verdict["decision"] == "block":
+    ...  # reject the deposit / withdrawal
+```
+
+### Custom thresholds & auto‑monitoring
+
+```python
+verdict = wdna.screen(
+    address,
+    thresholds={"review": 40, "block": 75},  # map riskScore -> decision (sanctioned always blocks)
+    monitor=True,                              # also watch this wallet and webhook me on changes
+)
+```
+
+### Batch (up to 25 addresses)
+
+```python
+resp = wdna.screen_batch([addr_a, addr_b, addr_c])
+blocked = [r for r in resp["results"] if r.get("decision") == "block"]
+```
+
+## Webhooks
+
+Register an endpoint (the signing secret is returned **once** — store it):
+
+```python
+hook = wdna.create_webhook(
+    "https://api.acme.com/walletdna",
+    events=["wallet.risk_changed", "wallet.sanctioned"],
+)
+secret = hook["secret"]
+```
+
+Verify incoming events with the raw request body and the `WalletDNA-Signature` header (Flask example):
+
+```python
+from flask import Flask, request, abort
+from walletdna import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/walletdna")
+def walletdna_webhook():
+    raw = request.get_data(as_text=True)
+    if not verify_webhook(raw, request.headers.get("WalletDNA-Signature", ""), WDNA_WEBHOOK_SECRET):
+        abort(400)
+    event = request.get_json()
+    # event["type"], event["data"] (a screening verdict + previousScore/label/reportUrl)
+    return "", 200
+```
+
+## Errors
+
+Failed requests raise `WalletDNAError` with `.status`, `.code`, and `.body`. A `429` means you've hit your monthly API limit — add credits in the dashboard.
+
+## Reference
+
+Full OpenAPI spec: <https://walletdna.com/api/openapi> · Docs: <https://walletdna.com/docs/api>

walletdna-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "walletdna"
+version = "1.0.0"
+description = "Official WalletDNA SDK — wallet screening (allow / review / block), batch screening, and signed webhook verification."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["walletdna", "wallet", "screening", "sanctions", "ofac", "aml", "crypto", "compliance", "webhooks"]
+authors = [{ name = "WalletDNA" }]
+dependencies = []
+
+[project.urls]
+Homepage = "https://walletdna.com/developer"
+Documentation = "https://walletdna.com/docs/api"
+Source = "https://github.com/wallet-dna/walletdna"
+
+[tool.setuptools]
+packages = ["walletdna"]

walletdna-1.0.0/setup.cfg

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

walletdna-1.0.0/walletdna/__init__.py

@@ -0,0 +1,11 @@
+"""Official WalletDNA Python SDK.
+
+Wallet screening (allow / review / block), batch screening, and signed
+webhook verification. API access requires an Advanced or Enterprise plan —
+create a key at https://walletdna.com/developer.
+"""
+
+from .client import WalletDNA, WalletDNAError, verify_webhook
+
+__all__ = ["WalletDNA", "WalletDNAError", "verify_webhook"]
+__version__ = "1.0.0"

walletdna-1.0.0/walletdna/client.py

@@ -0,0 +1,141 @@
+"""WalletDNA API client — dependency-free (standard library only)."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional, Sequence
+
+DEFAULT_BASE_URL = "https://walletdna.com"
+
+
+class WalletDNAError(Exception):
+    """Raised when the API returns a non-2xx response or the request fails."""
+
+    def __init__(self, message: str, status: Optional[int] = None,
+                 code: Optional[str] = None, body: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.body = body
+
+
+class WalletDNA:
+    """Thin client for the WalletDNA API.
+
+    Example:
+        wdna = WalletDNA(os.environ["WALLETDNA_API_KEY"])
+        verdict = wdna.screen("0x722122dF12D4e14e13Ac3b6895a86e84145b6967")
+        if verdict["decision"] == "block":
+            ...
+    """
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL,
+                 timeout: float = 60.0):
+        if not api_key or not isinstance(api_key, str):
+            raise WalletDNAError(
+                "An API key is required. Get one at https://walletdna.com/developer"
+            )
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _request(self, method: str, path: str,
+                 body: Optional[Dict[str, Any]] = None) -> Any:
+        data = None if body is None else json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            f"{self.base_url}{path}",
+            data=data,
+            method=method,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode("utf-8", "replace")
+            parsed: Any = None
+            try:
+                parsed = json.loads(raw) if raw else None
+            except json.JSONDecodeError:
+                parsed = raw
+            msg = (parsed.get("message") or parsed.get("error")) if isinstance(parsed, dict) else f"HTTP {exc.code}"
+            raise WalletDNAError(
+                msg or f"HTTP {exc.code}",
+                status=exc.code,
+                code=parsed.get("error") if isinstance(parsed, dict) else None,
+                body=parsed,
+            ) from None
+        except urllib.error.URLError as exc:
+            raise WalletDNAError(f"Request failed: {exc.reason}") from None
+
+    def screen(self, address: str, thresholds: Optional[Dict[str, int]] = None,
+               monitor: bool = False) -> Dict[str, Any]:
+        """Screen a single address. Returns the verdict dict."""
+        out = self._request("POST", "/api/v1/screen", {
+            "address": address,
+            "thresholds": thresholds,
+            "monitor": monitor,
+        })
+        return out["result"]
+
+    def screen_batch(self, addresses: Sequence[str],
+                     thresholds: Optional[Dict[str, int]] = None,
+                     monitor: bool = False) -> Dict[str, Any]:
+        """Screen up to 25 addresses. Returns the full response dict."""
+        return self._request("POST", "/api/v1/screen", {
+            "addresses": list(addresses),
+            "thresholds": thresholds,
+            "monitor": monitor,
+        })
+
+    def list_webhooks(self) -> Dict[str, Any]:
+        return self._request("GET", "/api/webhooks")
+
+    def create_webhook(self, url: str,
+                       events: Optional[List[str]] = None) -> Dict[str, Any]:
+        """Register a webhook endpoint. The signing secret is returned once."""
+        return self._request("POST", "/api/webhooks", {"url": url, "events": events})
+
+    def delete_webhook(self, webhook_id: str) -> Dict[str, Any]:
+        return self._request("DELETE", f"/api/webhooks/{urllib.parse.quote(webhook_id)}")
+
+
+def verify_webhook(raw_body: str, signature_header: str, secret: str,
+                   tolerance_sec: int = 300, now: Optional[int] = None) -> bool:
+    """Verify a WalletDNA-Signature header (format ``t=<unix>,v1=<hex>``).
+
+    Returns True only if the HMAC-SHA256 over ``f"{t}.{raw_body}"`` matches and
+    the timestamp is within ``tolerance_sec``. Pass the exact request body string.
+    """
+    if not signature_header or not secret:
+        return False
+    parts = {}
+    for piece in signature_header.split(","):
+        if "=" in piece:
+            key, _, val = piece.partition("=")
+            parts[key.strip()] = val.strip()
+    try:
+        ts = int(parts.get("t", ""))
+    except ValueError:
+        return False
+    sig = parts.get("v1")
+    if not sig:
+        return False
+
+    current = int(time.time()) if now is None else now
+    if abs(current - ts) > tolerance_sec:
+        return False
+
+    expected = hmac.new(secret.encode("utf-8"), f"{ts}.{raw_body}".encode("utf-8"),
+                        hashlib.sha256).hexdigest()
+    return hmac.compare_digest(expected, sig)

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

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: walletdna
+Version: 1.0.0
+Summary: Official WalletDNA SDK — wallet screening (allow / review / block), batch screening, and signed webhook verification.
+Author: WalletDNA
+License: MIT
+Project-URL: Homepage, https://walletdna.com/developer
+Project-URL: Documentation, https://walletdna.com/docs/api
+Project-URL: Source, https://github.com/wallet-dna/walletdna
+Keywords: walletdna,wallet,screening,sanctions,ofac,aml,crypto,compliance,webhooks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# walletdna (Python)
+
+Official Python SDK for the [WalletDNA](https://walletdna.com) API — screen any wallet for sanctions and high‑risk exposure, get a clear **allow / review / block** decision, and verify signed webhooks. Standard library only, no dependencies.
+
+API access requires an **Advanced** or **Enterprise** plan. Create an API key at <https://walletdna.com/developer>.
+
+## Install
+
+```sh
+pip install walletdna
+```
+
+Requires Python 3.8+.
+
+## Screen a wallet
+
+```python
+import os
+from walletdna import WalletDNA
+
+wdna = WalletDNA(os.environ["WALLETDNA_API_KEY"])
+
+verdict = wdna.screen("0x722122dF12D4e14e13Ac3b6895a86e84145b6967")
+print(verdict["decision"])  # "allow" | "review" | "block"
+
+if verdict["decision"] == "block":
+    ...  # reject the deposit / withdrawal
+```
+
+### Custom thresholds & auto‑monitoring
+
+```python
+verdict = wdna.screen(
+    address,
+    thresholds={"review": 40, "block": 75},  # map riskScore -> decision (sanctioned always blocks)
+    monitor=True,                              # also watch this wallet and webhook me on changes
+)
+```
+
+### Batch (up to 25 addresses)
+
+```python
+resp = wdna.screen_batch([addr_a, addr_b, addr_c])
+blocked = [r for r in resp["results"] if r.get("decision") == "block"]
+```
+
+## Webhooks
+
+Register an endpoint (the signing secret is returned **once** — store it):
+
+```python
+hook = wdna.create_webhook(
+    "https://api.acme.com/walletdna",
+    events=["wallet.risk_changed", "wallet.sanctioned"],
+)
+secret = hook["secret"]
+```
+
+Verify incoming events with the raw request body and the `WalletDNA-Signature` header (Flask example):
+
+```python
+from flask import Flask, request, abort
+from walletdna import verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/walletdna")
+def walletdna_webhook():
+    raw = request.get_data(as_text=True)
+    if not verify_webhook(raw, request.headers.get("WalletDNA-Signature", ""), WDNA_WEBHOOK_SECRET):
+        abort(400)
+    event = request.get_json()
+    # event["type"], event["data"] (a screening verdict + previousScore/label/reportUrl)
+    return "", 200
+```
+
+## Errors
+
+Failed requests raise `WalletDNAError` with `.status`, `.code`, and `.body`. A `429` means you've hit your monthly API limit — add credits in the dashboard.
+
+## Reference
+
+Full OpenAPI spec: <https://walletdna.com/api/openapi> · Docs: <https://walletdna.com/docs/api>

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

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+walletdna/__init__.py
+walletdna/client.py
+walletdna.egg-info/PKG-INFO
+walletdna.egg-info/SOURCES.txt
+walletdna.egg-info/dependency_links.txt
+walletdna.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+walletdna