degenscan-intel 0.1.0__tar.gz

degenscan_intel-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+data/*.db*
+data/universe.json
+.env
+mcp-publisher*
+_to_delete/
+packages/js/node_modules
+packages/js/dist
+packages/py/dist
+packages/py/*.egg-info

degenscan_intel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marbella Collins LLC (degenscan.io)
+
+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.

degenscan_intel-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.5
+Name: degenscan-intel
+Version: 0.1.0
+Summary: Cross-asset market-event intelligence for AI trading agents (SEC, Fed, regulators, disasters, halts, hacks, Polymarket, Hyperliquid perps). Pays per call in USDC via x402 or uses an API key.
+Project-URL: Homepage, https://intel.degenscan.io
+Project-URL: Documentation, https://intel.degenscan.io/llms.txt
+Project-URL: Repository, https://github.com/tradewr333-lgtm/degenscan-intel
+Author-email: Marbella Collins LLC <contact@degenscan.io>
+License: MIT
+License-File: LICENSE
+Keywords: agentkit,ai-agents,base,federal-reserve,funding-rate,hyperliquid,langchain,market-data,market-events,mcp,polymarket,sec-edgar,trading-bot,usdc,x402
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: x402
+Requires-Dist: eth-account>=0.13; extra == 'x402'
+Requires-Dist: x402>=2.24; extra == 'x402'
+Description-Content-Type: text/markdown
+
+# degenscan-intel
+
+Market-event intelligence for AI trading agents, paid per call in USDC (x402) or with an API key.
+
+One normalized feed of price-moving events from ~40 primary sources — SEC EDGAR (8-K, Form 4, 13D), Federal Reserve, Federal Register, ECB/BoE/BoJ, FTC/DOJ/FDA/CFTC/FCC, USGS earthquakes, NOAA/NHC storms, Nasdaq halts, DefiLlama hacks, Polymarket odds, Hyperliquid perps — scored against an exposure graph into per-asset impacts (`direction`, `confidence`, `path`). Deterministic, sub-200 ms, every event links to its source document.
+
+- Service: `https://intel.degenscan.io` · MCP: `POST https://intel.degenscan.io/mcp` · OpenAPI: `/openapi.json` · Docs for LLMs: `/llms.txt`
+- Prices: $0.001–$0.02 per call (brief $0.10). No subscription needed. Free trial: 100 calls/day/IP.
+- Operator: Marbella Collins LLC · MIT · Information and analytics only — not investment advice.
+
+## Install
+
+```bash
+pip install degenscan-intel            # API key / free trial
+pip install "degenscan-intel[x402]"    # + per-call USDC payments from an agent wallet
+```
+
+## 20-line trading-agent loop
+
+```python
+import os, time
+from degenscan_intel import Intel
+
+# Pick ONE:
+intel = Intel(private_key=os.environ["AGENT_WALLET_PK"])   # pays USDC on Base per call via x402 (HTTP 402 -> sign -> 200)
+# intel = Intel(api_key=os.environ["INTEL_API_KEY"])       # prepaid pack or Stripe plan
+# intel = Intel()                                          # free trial, 100 calls/day
+
+book = ["BTC", "ETH", "NVDA", "MSTR", "CL"]
+
+while True:
+    p = intel.pulse()                                                    # $0.001 — anything new in the last hour?
+    if p["high_severity"]:
+        for e in intel.events_since(since="4h", universe=book, min_confidence=0.4)["events"]:   # $0.005
+            for imp in (i for i in e["impacts"] if i["asset_id"] in book and i["confidence"] >= 0.5):
+                brief = intel.brief(imp["asset_id"])                     # $0.10 — pressure, headlines, filings, derivatives, catalysts
+                if not brief["tradable_now"]:
+                    continue                                             # venue closed -> wait for next_open
+                d = intel.derivs_for(imp["asset_id"]) if imp["asset_id"] in ("BTC", "ETH") else None   # $0.003 — funding/OI/premium
+                print(imp["asset_id"], "LONG" if imp["direction"] > 0 else "SHORT", imp["confidence"], e["title"], d and d["flags"])
+                # -> your execution logic here
+    time.sleep(3600)
+```
+
+Async: `from degenscan_intel import AsyncIntel` — same methods, `await`ed.
+
+## Buy a prepaid key with USDC (no human, no card)
+
+```python
+intel = Intel(private_key=os.environ["AGENT_WALLET_PK"])
+key = intel.buy_pack("pack_1k")["api_key"]     # $5 USDC -> 1,000 calls, lifetime. Also pack_10k ($40), pack_100k ($300)
+cheap = Intel(api_key=key)                      # no per-call signatures from here on
+cheap.key_status()                              # {"calls_used": ..., "calls_left": ...}
+```
+
+## Methods
+
+| Method | REST | Price | Returns |
+|---|---|---|---|
+| `pulse()` | `GET /v1/pulse` | $0.001 | event counts last hour by class, high-severity count, venues open |
+| `events_since(since, universe, min_confidence, limit)` | `GET /v1/events` | $0.005 | events with per-asset impacts, `tradable_now`, `next_open` |
+| `impact_for(asset, since)` | `GET /v1/impact/{asset}` | $0.003 | net bias on one asset + driving events |
+| `exposure_graph(asset, depth)` | `GET /v1/graph/{asset}` | $0.002 | suppliers, countries, commodities, regulators, indices |
+| `regime()` | `GET /v1/regime` | $0.01 | venues open, 24h pressure by asset, top events, prediction markets |
+| `explain(event_id)` | `GET /v1/explain/{id}` | $0.02 | reasoning behind one impact |
+| `polymarket(market)` | `GET /v1/polymarket/{market}` | $0.01 | current odds + primary events that bear on the question |
+| `news_for(ticker)` | `GET /v1/news/{ticker}` | $0.002 | headlines with tier, corroboration, sentiment |
+| `filings_for(ticker, forms=[...])` | `GET /v1/filings/{ticker}` | $0.002 | 8-K, Form 4, 13D/G, S-1 |
+| `calendar(days, types)` | `GET /v1/calendar` | $0.002 | FOMC, CPI, NFP, PCE, GDP, earnings, auctions |
+| `derivs_for(symbol)` | `GET /v1/derivs/{symbol}` | $0.003 | Hyperliquid funding (1h/8h/annualized), predicted funding by venue, OI, premium, 24h volume, flags |
+| `brief(asset)` | `GET /v1/brief/{asset}` | $0.10 | everything above for one asset in one call |
+| `universe()`, `sources()`, `health()`, `plans()`, `packs()` | — | free | coverage, connector status, card plans, USDC packs |
+
+Every paid response carries `_billing: {tool, price_usd, method}`; x402 responses also carry `_payment_response` (settlement receipt with tx hash).
+
+## How payment works (x402)
+
+1. Agent calls a priced route → server answers **HTTP 402** with `PAYMENT-REQUIRED` (USDC on Base `eip155:8453` or Solana, amount, payTo).
+2. The client (Coinbase's `x402` package) signs an EIP-3009 USDC transfer with your wallet — gas is paid by the facilitator (Coinbase CDP / PayAI).
+3. The request is retried with the signature → **200** + data + `PAYMENT-RESPONSE` (tx hash).
+
+Use a dedicated agent wallet with a few USDC. Never your main wallet.
+
+## Reading the output
+
+- `direction`: `1` supportive, `-1` negative, `0` unclear. `confidence` (0..1) = source tier × severity/novelty × graph-path weight — a ranking signal, **not a probability**.
+- `corroboration.count` = independent sources. Primary sources (SEC, Fed, USGS) originate events; media only corroborates.
+- `path` shows the exposure route, e.g. `nat.quake → facility:TSMC-Fab18 → company:TSM → company:NVDA`.
+- `universe_version` is stamped on every response for reproducible backtests.
+
+## Also available as
+
+- **MCP server** (Claude Code, Cursor, OpenClaw): `{"mcpServers": {"degenscan-intel": {"url": "https://intel.degenscan.io/mcp"}}}`
+- **Agent skill**: `npx skills add tradewr333-lgtm/degenscan-intel`
+- **TypeScript/JavaScript**: `npm i @degenscan/intel`
+- **Public metrics** (paying wallets, tx hashes, operator wallets excluded): `https://intel.degenscan.io/v1/metrics`
+
+## Limits
+
+US-equity-heavy coverage (top-100 by volume + indices), 15 crypto, main commodities/FX/rates — check `universe()`. No price data, no forecasts. Liquidations are not part of `derivs_for`. Sources marked best-effort in `sources()` may go quiet.
+
+MIT © Marbella Collins LLC · contact@degenscan.io

degenscan_intel-0.1.0/README.md

@@ -0,0 +1,102 @@
+# degenscan-intel
+
+Market-event intelligence for AI trading agents, paid per call in USDC (x402) or with an API key.
+
+One normalized feed of price-moving events from ~40 primary sources — SEC EDGAR (8-K, Form 4, 13D), Federal Reserve, Federal Register, ECB/BoE/BoJ, FTC/DOJ/FDA/CFTC/FCC, USGS earthquakes, NOAA/NHC storms, Nasdaq halts, DefiLlama hacks, Polymarket odds, Hyperliquid perps — scored against an exposure graph into per-asset impacts (`direction`, `confidence`, `path`). Deterministic, sub-200 ms, every event links to its source document.
+
+- Service: `https://intel.degenscan.io` · MCP: `POST https://intel.degenscan.io/mcp` · OpenAPI: `/openapi.json` · Docs for LLMs: `/llms.txt`
+- Prices: $0.001–$0.02 per call (brief $0.10). No subscription needed. Free trial: 100 calls/day/IP.
+- Operator: Marbella Collins LLC · MIT · Information and analytics only — not investment advice.
+
+## Install
+
+```bash
+pip install degenscan-intel            # API key / free trial
+pip install "degenscan-intel[x402]"    # + per-call USDC payments from an agent wallet
+```
+
+## 20-line trading-agent loop
+
+```python
+import os, time
+from degenscan_intel import Intel
+
+# Pick ONE:
+intel = Intel(private_key=os.environ["AGENT_WALLET_PK"])   # pays USDC on Base per call via x402 (HTTP 402 -> sign -> 200)
+# intel = Intel(api_key=os.environ["INTEL_API_KEY"])       # prepaid pack or Stripe plan
+# intel = Intel()                                          # free trial, 100 calls/day
+
+book = ["BTC", "ETH", "NVDA", "MSTR", "CL"]
+
+while True:
+    p = intel.pulse()                                                    # $0.001 — anything new in the last hour?
+    if p["high_severity"]:
+        for e in intel.events_since(since="4h", universe=book, min_confidence=0.4)["events"]:   # $0.005
+            for imp in (i for i in e["impacts"] if i["asset_id"] in book and i["confidence"] >= 0.5):
+                brief = intel.brief(imp["asset_id"])                     # $0.10 — pressure, headlines, filings, derivatives, catalysts
+                if not brief["tradable_now"]:
+                    continue                                             # venue closed -> wait for next_open
+                d = intel.derivs_for(imp["asset_id"]) if imp["asset_id"] in ("BTC", "ETH") else None   # $0.003 — funding/OI/premium
+                print(imp["asset_id"], "LONG" if imp["direction"] > 0 else "SHORT", imp["confidence"], e["title"], d and d["flags"])
+                # -> your execution logic here
+    time.sleep(3600)
+```
+
+Async: `from degenscan_intel import AsyncIntel` — same methods, `await`ed.
+
+## Buy a prepaid key with USDC (no human, no card)
+
+```python
+intel = Intel(private_key=os.environ["AGENT_WALLET_PK"])
+key = intel.buy_pack("pack_1k")["api_key"]     # $5 USDC -> 1,000 calls, lifetime. Also pack_10k ($40), pack_100k ($300)
+cheap = Intel(api_key=key)                      # no per-call signatures from here on
+cheap.key_status()                              # {"calls_used": ..., "calls_left": ...}
+```
+
+## Methods
+
+| Method | REST | Price | Returns |
+|---|---|---|---|
+| `pulse()` | `GET /v1/pulse` | $0.001 | event counts last hour by class, high-severity count, venues open |
+| `events_since(since, universe, min_confidence, limit)` | `GET /v1/events` | $0.005 | events with per-asset impacts, `tradable_now`, `next_open` |
+| `impact_for(asset, since)` | `GET /v1/impact/{asset}` | $0.003 | net bias on one asset + driving events |
+| `exposure_graph(asset, depth)` | `GET /v1/graph/{asset}` | $0.002 | suppliers, countries, commodities, regulators, indices |
+| `regime()` | `GET /v1/regime` | $0.01 | venues open, 24h pressure by asset, top events, prediction markets |
+| `explain(event_id)` | `GET /v1/explain/{id}` | $0.02 | reasoning behind one impact |
+| `polymarket(market)` | `GET /v1/polymarket/{market}` | $0.01 | current odds + primary events that bear on the question |
+| `news_for(ticker)` | `GET /v1/news/{ticker}` | $0.002 | headlines with tier, corroboration, sentiment |
+| `filings_for(ticker, forms=[...])` | `GET /v1/filings/{ticker}` | $0.002 | 8-K, Form 4, 13D/G, S-1 |
+| `calendar(days, types)` | `GET /v1/calendar` | $0.002 | FOMC, CPI, NFP, PCE, GDP, earnings, auctions |
+| `derivs_for(symbol)` | `GET /v1/derivs/{symbol}` | $0.003 | Hyperliquid funding (1h/8h/annualized), predicted funding by venue, OI, premium, 24h volume, flags |
+| `brief(asset)` | `GET /v1/brief/{asset}` | $0.10 | everything above for one asset in one call |
+| `universe()`, `sources()`, `health()`, `plans()`, `packs()` | — | free | coverage, connector status, card plans, USDC packs |
+
+Every paid response carries `_billing: {tool, price_usd, method}`; x402 responses also carry `_payment_response` (settlement receipt with tx hash).
+
+## How payment works (x402)
+
+1. Agent calls a priced route → server answers **HTTP 402** with `PAYMENT-REQUIRED` (USDC on Base `eip155:8453` or Solana, amount, payTo).
+2. The client (Coinbase's `x402` package) signs an EIP-3009 USDC transfer with your wallet — gas is paid by the facilitator (Coinbase CDP / PayAI).
+3. The request is retried with the signature → **200** + data + `PAYMENT-RESPONSE` (tx hash).
+
+Use a dedicated agent wallet with a few USDC. Never your main wallet.
+
+## Reading the output
+
+- `direction`: `1` supportive, `-1` negative, `0` unclear. `confidence` (0..1) = source tier × severity/novelty × graph-path weight — a ranking signal, **not a probability**.
+- `corroboration.count` = independent sources. Primary sources (SEC, Fed, USGS) originate events; media only corroborates.
+- `path` shows the exposure route, e.g. `nat.quake → facility:TSMC-Fab18 → company:TSM → company:NVDA`.
+- `universe_version` is stamped on every response for reproducible backtests.
+
+## Also available as
+
+- **MCP server** (Claude Code, Cursor, OpenClaw): `{"mcpServers": {"degenscan-intel": {"url": "https://intel.degenscan.io/mcp"}}}`
+- **Agent skill**: `npx skills add tradewr333-lgtm/degenscan-intel`
+- **TypeScript/JavaScript**: `npm i @degenscan/intel`
+- **Public metrics** (paying wallets, tx hashes, operator wallets excluded): `https://intel.degenscan.io/v1/metrics`
+
+## Limits
+
+US-equity-heavy coverage (top-100 by volume + indices), 15 crypto, main commodities/FX/rates — check `universe()`. No price data, no forecasts. Liquidations are not part of `derivs_for`. Sources marked best-effort in `sources()` may go quiet.
+
+MIT © Marbella Collins LLC · contact@degenscan.io

degenscan_intel-0.1.0/degenscan_intel/__init__.py

@@ -0,0 +1,202 @@
+"""degenscan-intel — client for Degenscan Intel (https://intel.degenscan.io)
+
+Cross-asset market-event intelligence for AI trading agents: ~40 primary sources (SEC EDGAR,
+Federal Reserve, Federal Register, ECB/BoE/BoJ, FTC/DOJ/FDA/CFTC, USGS, NOAA, Nasdaq halts,
+DefiLlama, Polymarket, Hyperliquid) normalized into one event schema and scored against an
+exposure graph into per-asset impacts.
+
+Three ways to pay, all automatic:
+  * ``private_key``  -> pays each call in USDC on Base via x402 (HTTP 402 -> sign -> 200). Needs ``pip install degenscan-intel[x402]``.
+  * ``api_key``      -> prepaid pack bought with USDC (``buy_pack``) or a Stripe subscription.
+  * ``free_trial``   -> 100 free calls/day per IP (sends ``X-Free-Trial: 1``). Default when nothing else is set.
+
+Information and analytics only — not investment advice. Operator: Marbella Collins LLC.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Iterable, Optional
+
+import httpx
+
+__all__ = ["Intel", "AsyncIntel", "IntelError", "__version__"]
+__version__ = "0.1.0"
+DEFAULT_BASE_URL = "https://intel.degenscan.io"
+
+
+class IntelError(Exception):
+    def __init__(self, message: str, status: int, body: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+def _q(params: dict[str, Any]) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for k, v in params.items():
+        if v is None:
+            continue
+        out[k] = ",".join(map(str, v)) if isinstance(v, (list, tuple)) else str(v)
+    return out
+
+
+class AsyncIntel:
+    """Async client. Use ``Intel`` for a blocking wrapper."""
+
+    def __init__(self, *, base_url: str = DEFAULT_BASE_URL, private_key: Optional[str] = None, api_key: Optional[str] = None,
+                 free_trial: Optional[bool] = None, timeout: float = 20.0, client: Optional[httpx.AsyncClient] = None):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.private_key = private_key
+        self.free_trial = free_trial if free_trial is not None else (not api_key and not private_key)
+        self.timeout = timeout
+        self._client = client
+
+    # ---- transport ------------------------------------------------------------------
+    async def _http(self) -> httpx.AsyncClient:
+        if self._client is not None:
+            return self._client
+        if not self.private_key:
+            self._client = httpx.AsyncClient(timeout=self.timeout)
+            return self._client
+        try:
+            from eth_account import Account
+            from x402 import SchemeRegistration, x402ClientConfig
+            from x402.http.clients import wrapHttpxWithPaymentFromConfig
+            from x402.mechanisms.evm.exact import ExactEvmScheme
+            from x402.mechanisms.evm.signers import EthAccountSigner
+        except ImportError as e:  # pragma: no cover
+            raise ImportError("Per-call USDC payments need: pip install 'degenscan-intel[x402]'") from e
+        pk = self.private_key.strip()
+        if not pk.startswith("0x"):
+            pk = "0x" + pk
+        account = Account.from_key(pk)
+        cfg = x402ClientConfig(schemes=[SchemeRegistration(network="eip155:8453", client=ExactEvmScheme(signer=EthAccountSigner(account)))])
+        self._client = wrapHttpxWithPaymentFromConfig(cfg, timeout=self.timeout)
+        return self._client
+
+    def _headers(self, json_body: bool = False) -> dict[str, str]:
+        h = {"accept": "application/json", "user-agent": f"degenscan-intel-py/{__version__}"}
+        if json_body:
+            h["content-type"] = "application/json"
+        if self.api_key:
+            h["x-api-key"] = self.api_key
+        elif self.free_trial and not self.private_key:
+            h["x-free-trial"] = "1"
+        return h
+
+    async def request(self, path: str, *, method: str = "GET", query: Optional[dict[str, Any]] = None, body: Any = None) -> Any:
+        """Low-level request. Returns parsed JSON; raises IntelError on non-2xx (including an unpaid 402)."""
+        client = await self._http()
+        res = await client.request(method, self.base_url + path, params=_q(query or {}), headers=self._headers(body is not None),
+                                   content=json.dumps(body) if body is not None else None)
+        try:
+            data = res.json() if res.content else None
+        except ValueError:
+            data = res.text
+        if res.status_code >= 400:
+            msg = ("Payment required — pass private_key (USDC on Base), api_key, or free_trial=True" if res.status_code == 402
+                   else (data or {}).get("error", f"HTTP {res.status_code}") if isinstance(data, dict) else f"HTTP {res.status_code}")
+            raise IntelError(msg, res.status_code, data)
+        pr = res.headers.get("payment-response")
+        if pr and isinstance(data, dict):
+            data["_payment_response"] = pr
+        return data
+
+    async def aclose(self) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+
+    # ---- free -----------------------------------------------------------------------
+    async def universe(self): return await self.request("/v1/universe")
+    async def sources(self): return await self.request("/v1/sources")
+    async def health(self): return await self.request("/health")
+    async def plans(self): return await self.request("/v1/plans")
+    async def packs(self): return await self.request("/v1/keys/packs")
+
+    # ---- paid -----------------------------------------------------------------------
+    async def pulse(self):
+        """$0.001 — cheapest probe: event counts in the last hour by class + venues open."""
+        return await self.request("/v1/pulse")
+
+    async def events_since(self, since: str = "4h", universe: Optional[Iterable[str]] = None, min_confidence: Optional[float] = None,
+                           kinds: Optional[Iterable[str]] = None, limit: Optional[int] = None):
+        """$0.005 — all events since `since` touching your universe, with per-asset impacts."""
+        return await self.request("/v1/events", query={"since": since, "universe": list(universe) if universe else None,
+                                                       "min_confidence": min_confidence, "kinds": list(kinds) if kinds else None, "limit": limit})
+
+    async def impact_for(self, asset_id: str, since: str = "24h", limit: Optional[int] = None):
+        """$0.003 — net pressure on one asset and the events driving it."""
+        return await self.request(f"/v1/impact/{asset_id}", query={"since": since, "limit": limit})
+
+    async def exposure_graph(self, asset_id: str, depth: int = 2):
+        """$0.002 — second-order exposure graph."""
+        return await self.request(f"/v1/graph/{asset_id}", query={"depth": depth})
+
+    async def regime(self):
+        """$0.01 — venues open, 24h pressure by asset, top events, prediction markets."""
+        return await self.request("/v1/regime")
+
+    async def explain(self, event_id: str):
+        """$0.02 — the reasoning behind one impact."""
+        return await self.request(f"/v1/explain/{event_id}")
+
+    async def polymarket(self, market: str, since: str = "48h", limit: Optional[int] = None):
+        """$0.01 — Polymarket market (id, slug or question) -> odds + primary-source events that bear on it."""
+        from urllib.parse import quote
+        return await self.request(f"/v1/polymarket/{quote(market, safe='')}", query={"since": since, "limit": limit})
+
+    async def news_for(self, ticker: str, since: str = "24h", limit: Optional[int] = None):
+        """$0.002 — headlines on one asset with tier, corroboration and heuristic sentiment."""
+        return await self.request(f"/v1/news/{ticker}", query={"since": since, "limit": limit})
+
+    async def filings_for(self, ticker: str, since: str = "7d", forms: Optional[Iterable[str]] = None, limit: Optional[int] = None):
+        """$0.002 — SEC filings (8-K, Form 4, 13D/G, S-1) on one issuer."""
+        return await self.request(f"/v1/filings/{ticker}", query={"since": since, "forms": list(forms) if forms else None, "limit": limit})
+
+    async def calendar(self, days: int = 7, types: Optional[Iterable[str]] = None, universe: Optional[Iterable[str]] = None):
+        """$0.002 — upcoming macro prints, FOMC, earnings, auctions."""
+        return await self.request("/v1/calendar", query={"days": days, "types": list(types) if types else None, "universe": list(universe) if universe else None})
+
+    async def derivs_for(self, symbol: str, since: str = "24h"):
+        """$0.003 — Hyperliquid perp microstructure: funding (1h/8h/annualized), predicted funding by venue, OI, premium, volume, flags + event pressure."""
+        return await self.request(f"/v1/derivs/{symbol}", query={"since": since})
+
+    async def brief(self, asset_id: str, since: str = "24h"):
+        """$0.10 — one-call pre-trade briefing for one asset."""
+        return await self.request(f"/v1/brief/{asset_id}", query={"since": since})
+
+    # ---- keys -----------------------------------------------------------------------
+    async def buy_pack(self, pack: str = "pack_1k"):
+        """Buy a prepaid API key with USDC (needs private_key). pack_1k $5 · pack_10k $40 · pack_100k $300 -> {api_key, total_calls}."""
+        if not self.private_key and self._client is None:
+            raise IntelError("buy_pack needs a paying wallet (private_key) — it is paid in USDC", 400)
+        return await self.request(f"/v1/keys/x402/{pack}", method="POST", body={})
+
+    async def key_status(self):
+        if not self.api_key:
+            raise IntelError("key_status needs api_key", 400)
+        return await self.request("/v1/keys/me")
+
+
+class Intel:
+    """Blocking client — same methods as AsyncIntel, without ``await``."""
+
+    def __init__(self, **kwargs: Any):
+        self._a = AsyncIntel(**kwargs)
+
+    def __getattr__(self, name: str):
+        attr = getattr(self._a, name)
+        if not callable(attr):
+            return attr
+
+        def run(*args: Any, **kw: Any):
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+            if loop and loop.is_running():
+                raise RuntimeError("Inside an event loop use AsyncIntel and await the call")
+            return asyncio.run(attr(*args, **kw))
+        return run

degenscan_intel-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "degenscan-intel"
+version = "0.1.0"
+description = "Cross-asset market-event intelligence for AI trading agents (SEC, Fed, regulators, disasters, halts, hacks, Polymarket, Hyperliquid perps). Pays per call in USDC via x402 or uses an API key."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Marbella Collins LLC", email = "contact@degenscan.io" }]
+requires-python = ">=3.10"
+keywords = ["x402", "ai-agents", "trading-bot", "market-data", "sec-edgar", "federal-reserve", "hyperliquid", "funding-rate", "polymarket", "mcp", "usdc", "base", "market-events", "langchain", "agentkit"]
+classifiers = ["License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Topic :: Office/Business :: Financial", "Intended Audience :: Developers"]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+x402 = ["x402>=2.24", "eth-account>=0.13"]
+
+[project.urls]
+Homepage = "https://intel.degenscan.io"
+Documentation = "https://intel.degenscan.io/llms.txt"
+Repository = "https://github.com/tradewr333-lgtm/degenscan-intel"
+
+[tool.hatch.build.targets.wheel]
+packages = ["degenscan_intel"]