dpx-sdk 0.1.0__py3-none-any.whl

dpx_sdk/__init__.py

@@ -0,0 +1,5 @@
+from .client import DPX, DPXError
+from .types import QuoteResult, SettlementResult, OracleStatus, EsgScore
+
+__all__ = ["DPX", "DPXError", "QuoteResult", "SettlementResult", "OracleStatus", "EsgScore"]
+__version__ = "0.1.0"

dpx_sdk/client.py

@@ -0,0 +1,162 @@
+"""
+DPX Python SDK — thin async client over the DPX REST + Settlement Agent APIs.
+"""
+
+from __future__ import annotations
+
+import httpx
+from typing import Optional
+
+from .types import QuoteResult, SettlementResult, OracleStatus, EsgScore
+
+STABILITY_URL  = "https://stability.untitledfinancial.com"
+ESG_URL        = "https://esg.untitledfinancial.com"
+AGENT_URL      = "https://agent.untitledfinancial.com"
+COMPLIANCE_URL = "https://compliance.untitledfinancial.com"
+DEFAULT_TIMEOUT = 20.0
+
+
+class DPXError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class DPX:
+    """
+    Synchronous DPX client.
+
+    Usage:
+        from dpx_sdk import DPX
+        dpx = DPX()
+        quote = dpx.quote(amount_usd=500_000, has_fx=True, esg_score=75)
+        result = dpx.settle(
+            amount=500_000,
+            source_currency="USD",
+            destination_currency="EUR",
+            recipient_address="0x...",
+            sandbox=True,
+        )
+    """
+
+    def __init__(self, timeout: float = DEFAULT_TIMEOUT):
+        self._client = httpx.Client(
+            timeout=timeout,
+            headers={"User-Agent": "dpx-sdk-python/0.1.0"},
+        )
+
+    def _get(self, url: str, params: Optional[dict] = None) -> dict:
+        r = self._client.get(url, params=params)
+        if not r.is_success:
+            raise DPXError(f"HTTP {r.status_code}: {r.text[:200]}", r.status_code)
+        return r.json()
+
+    def _post(self, url: str, body: dict) -> dict:
+        r = self._client.post(url, json=body)
+        if not r.is_success:
+            raise DPXError(f"HTTP {r.status_code}: {r.text[:200]}", r.status_code)
+        return r.json()
+
+    def quote(
+        self,
+        amount_usd: float,
+        has_fx: bool = True,
+        esg_score: float = 75,
+        monthly_volume_usd: Optional[float] = None,
+    ) -> QuoteResult:
+        params: dict = {"amountUsd": amount_usd, "hasFx": str(has_fx).lower(), "esgScore": int(esg_score)}
+        if monthly_volume_usd is not None:
+            params["monthlyVolumeUsd"] = monthly_volume_usd
+        d = self._get(f"{AGENT_URL}/quote", params)
+        fees = d.get("fees", {})
+        total = fees.get("total", {})
+        return QuoteResult(
+            quote_id=d.get("quoteId", ""),
+            amount_usd=d.get("amountUsd", amount_usd),
+            net_amount_usd=d.get("netAmountUsd", 0.0),
+            total_fee_pct=total.get("pct", 0.0),
+            total_fee_usd=total.get("usd", 0.0),
+            oracle_status=d.get("oracleStatus", ""),
+            oracle_score=d.get("oracleScore", 0.0),
+            tier=d.get("tier", ""),
+            expires_at=d.get("expiresAt", ""),
+            reasoning=d.get("reasoning", ""),
+            raw=d,
+        )
+
+    def oracle_status(self) -> OracleStatus:
+        d = self._get(f"{STABILITY_URL}/reliability")
+        return OracleStatus(
+            status=d.get("status", ""),
+            score=float(d.get("stabilityScore", d.get("score", 0))),
+            recommendation=d.get("recommendation", ""),
+            peg_deviation=float(d.get("pegDeviation", 0)),
+            outlook=d.get("outlook", ""),
+            reasoning=d.get("reasoning", d.get("briefing", "")),
+            timestamp=d.get("timestamp", ""),
+            raw=d,
+        )
+
+    def esg_score(self, address: Optional[str] = None) -> EsgScore:
+        path = f"/esg-score/{address}" if address else "/esg-score"
+        d = self._get(f"{ESG_URL}{path}")
+        return EsgScore(
+            address=d.get("address", address or "default"),
+            esg_score=float(d.get("esgScore", d.get("score", 0))),
+            environmental=float(d.get("environmental", 0)),
+            social=float(d.get("social", 0)),
+            governance=float(d.get("governance", 0)),
+            fee_pct=float(d.get("feePct", 0)),
+            tier=d.get("tier", ""),
+            updated_at=d.get("updatedAt", ""),
+            raw=d,
+        )
+
+    def settle(
+        self,
+        amount: float,
+        source_currency: str,
+        destination_currency: str,
+        recipient_address: str,
+        purpose: str = "vendor-payment",
+        reference_id: Optional[str] = None,
+        quote_id: Optional[str] = None,
+        sandbox: bool = True,
+    ) -> SettlementResult:
+        body: dict = {
+            "amount": amount,
+            "sourceCurrency": source_currency,
+            "destinationCurrency": destination_currency,
+            "recipientAddress": recipient_address,
+            "purpose": purpose,
+            "sandbox": sandbox,
+        }
+        if reference_id:
+            body["referenceId"] = reference_id
+        if quote_id:
+            body["quoteId"] = quote_id
+        d = self._post(f"{AGENT_URL}/settle", body)
+        result = d.get("result", d)
+        return SettlementResult(
+            settlement_id=result.get("settlementId", ""),
+            status=result.get("status", ""),
+            tx_hash=result.get("txHash"),
+            net_amount=float(result.get("netAmount", 0)),
+            fees_total=float(result.get("feesTotal", 0)),
+            oracle_status=result.get("oracleStatus", ""),
+            reasoning=result.get("reasoning", ""),
+            timestamp=result.get("timestamp", ""),
+            raw=d,
+        )
+
+    def screen(self, address: str) -> dict:
+        return self._get(f"{COMPLIANCE_URL}/screen", {"address": address})
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()

dpx_sdk/tools/__init__.py

@@ -0,0 +1,12 @@
+from .langchain import DPXToolkit, DPXQuoteTool, DPXSettleTool, DPXOracleTool, DPXEsgTool, DPXComplianceTool
+from .llamaindex import DPXToolSpec
+
+__all__ = [
+    "DPXToolkit",
+    "DPXQuoteTool",
+    "DPXSettleTool",
+    "DPXOracleTool",
+    "DPXEsgTool",
+    "DPXComplianceTool",
+    "DPXToolSpec",
+]

dpx_sdk/tools/langchain.py

@@ -0,0 +1,239 @@
+"""
+DPX LangChain Toolkit
+
+Usage:
+    from dpx_sdk.tools import DPXToolkit
+    from langchain.agents import initialize_agent, AgentType
+    from langchain_openai import ChatOpenAI   # or any LLM
+
+    tools = DPXToolkit().get_tools()
+    agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
+    agent.run("Get a quote for sending $500K USD to EUR and check oracle stability")
+
+Published to LangChain Hub: untitledfinancial/dpx-toolkit
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional, Type, List
+
+try:
+    from langchain.tools import BaseTool
+    from langchain.tools import BaseToolkit
+    from langchain_core.tools import BaseTool as CoreBaseTool
+    from pydantic import BaseModel, Field
+    _LANGCHAIN_AVAILABLE = True
+except ImportError:
+    _LANGCHAIN_AVAILABLE = False
+    BaseTool = object            # type: ignore
+    BaseToolkit = object         # type: ignore
+    BaseModel = object           # type: ignore
+    Field = lambda *a, **kw: None  # type: ignore
+
+from ..client import DPX
+
+
+def _require_langchain():
+    if not _LANGCHAIN_AVAILABLE:
+        raise ImportError("Install langchain: pip install langchain langchain-core")
+
+
+# ── Input schemas ──────────────────────────────────────────────────────────────
+
+if _LANGCHAIN_AVAILABLE:
+    class QuoteInput(BaseModel):
+        amount_usd: float = Field(description="Settlement amount in USD")
+        has_fx: bool = Field(default=True, description="True if cross-currency (adds FX fee)")
+        esg_score: float = Field(default=75, description="Counterparty ESG score 0–100")
+
+    class SettleInput(BaseModel):
+        amount: float = Field(description="Settlement amount")
+        source_currency: str = Field(description="Source currency: USD, EUR, GBP, USDC, EURC")
+        destination_currency: str = Field(description="Destination currency: USD, EUR, GBP, USDC, EURC")
+        recipient_address: str = Field(description="On-chain recipient wallet address (0x...)")
+        purpose: str = Field(default="vendor-payment", description="Payment purpose")
+        sandbox: bool = Field(default=True, description="Sandbox mode — set False for live execution")
+
+    class EsgInput(BaseModel):
+        address: Optional[str] = Field(default=None, description="Wallet address (0x...). Omit for protocol default.")
+
+    class ComplianceInput(BaseModel):
+        address: str = Field(description="Wallet address or entity name to screen")
+
+
+# ── Tools ──────────────────────────────────────────────────────────────────────
+
+class DPXQuoteTool(BaseTool):
+    """Get a binding settlement fee quote from DPX."""
+    name: str = "dpx_quote"
+    description: str = (
+        "Get a binding fee quote for a DPX cross-border settlement. "
+        "Returns all-in rate, fee breakdown, net amount, oracle status, and AI reasoning. "
+        "Quote is valid for 300 seconds. Always call before dpx_settle."
+    )
+    args_schema: Type[BaseModel] = QuoteInput if _LANGCHAIN_AVAILABLE else object  # type: ignore
+
+    def _run(self, amount_usd: float, has_fx: bool = True, esg_score: float = 75) -> str:
+        _require_langchain()
+        with DPX() as dpx:
+            q = dpx.quote(amount_usd=amount_usd, has_fx=has_fx, esg_score=esg_score)
+        return json.dumps({
+            "quote_id": q.quote_id,
+            "amount_usd": q.amount_usd,
+            "net_amount_usd": q.net_amount_usd,
+            "total_fee_pct": q.total_fee_pct,
+            "total_fee_usd": q.total_fee_usd,
+            "oracle_status": q.oracle_status,
+            "tier": q.tier,
+            "expires_at": q.expires_at,
+            "reasoning": q.reasoning,
+        }, indent=2)
+
+    async def _arun(self, *args, **kwargs) -> str:
+        return self._run(*args, **kwargs)
+
+
+class DPXSettleTool(BaseTool):
+    """Execute a cross-border settlement through DPX."""
+    name: str = "dpx_settle"
+    description: str = (
+        "Execute a DPX cross-border or domestic settlement. "
+        "Checks oracle conditions, runs ESG scoring and compliance checks, "
+        "then executes on-chain (or returns sandbox result if sandbox=True). "
+        "Returns settlement ID, tx hash, net amount, fees, and AI reasoning. "
+        "Default sandbox=True — set False only for live execution with explicit user confirmation."
+    )
+    args_schema: Type[BaseModel] = SettleInput if _LANGCHAIN_AVAILABLE else object  # type: ignore
+
+    def _run(
+        self,
+        amount: float,
+        source_currency: str,
+        destination_currency: str,
+        recipient_address: str,
+        purpose: str = "vendor-payment",
+        sandbox: bool = True,
+    ) -> str:
+        _require_langchain()
+        with DPX() as dpx:
+            r = dpx.settle(
+                amount=amount,
+                source_currency=source_currency,
+                destination_currency=destination_currency,
+                recipient_address=recipient_address,
+                purpose=purpose,
+                sandbox=sandbox,
+            )
+        return json.dumps({
+            "settlement_id": r.settlement_id,
+            "status": r.status,
+            "tx_hash": r.tx_hash,
+            "net_amount": r.net_amount,
+            "fees_total": r.fees_total,
+            "oracle_status": r.oracle_status,
+            "reasoning": r.reasoning,
+            "timestamp": r.timestamp,
+        }, indent=2)
+
+    async def _arun(self, *args, **kwargs) -> str:
+        return self._run(*args, **kwargs)
+
+
+class DPXOracleTool(BaseTool):
+    """Check live macro stability before a settlement."""
+    name: str = "dpx_oracle_status"
+    description: str = (
+        "Get live macro stability assessment from the DPX Stability Oracle. "
+        "Returns stability score (0–100), status (STABLE/CAUTION/UNSTABLE), "
+        "recommendation (PROCEED/CAUTION/HOLD), peg deviation in bps, and AI reasoning. "
+        "Call before large settlements — UNSTABLE status means hold."
+    )
+
+    def _run(self) -> str:
+        _require_langchain()
+        with DPX() as dpx:
+            o = dpx.oracle_status()
+        return json.dumps({
+            "status": o.status,
+            "score": o.score,
+            "recommendation": o.recommendation,
+            "peg_deviation_bps": o.peg_deviation,
+            "outlook": o.outlook,
+            "reasoning": o.reasoning,
+        }, indent=2)
+
+    async def _arun(self) -> str:
+        return self._run()
+
+
+class DPXEsgTool(BaseTool):
+    """Score a counterparty wallet for ESG risk."""
+    name: str = "dpx_esg_score"
+    description: str = (
+        "Get the ESG counterparty risk score for a wallet address. "
+        "Required for EU SFDR Principal Adverse Impact reporting and CSRD disclosure. "
+        "Returns E/S/G sub-scores, composite score (0–100), and the fee adjustment "
+        "this score produces at settlement. Updated hourly."
+    )
+    args_schema: Type[BaseModel] = EsgInput if _LANGCHAIN_AVAILABLE else object  # type: ignore
+
+    def _run(self, address: Optional[str] = None) -> str:
+        _require_langchain()
+        with DPX() as dpx:
+            e = dpx.esg_score(address=address)
+        return json.dumps({
+            "address": e.address,
+            "esg_score": e.esg_score,
+            "environmental": e.environmental,
+            "social": e.social,
+            "governance": e.governance,
+            "fee_pct": e.fee_pct,
+            "tier": e.tier,
+        }, indent=2)
+
+    async def _arun(self, *args, **kwargs) -> str:
+        return self._run(*args, **kwargs)
+
+
+class DPXComplianceTool(BaseTool):
+    """Screen a counterparty through DPX AML/FATF compliance oracle."""
+    name: str = "dpx_compliance_screen"
+    description: str = (
+        "Screen a wallet address or entity through the DPX Compliance Oracle. "
+        "Runs FATF R16 Travel Rule, AML behavioural analysis (z-score anomaly + "
+        "graph risk), sanctions screening (OFAC SDN), MiCA, and GENIUS Act checks. "
+        "Returns APPROVED / FLAGGED / BLOCKED with full reasoning. "
+        "Call before every settlement for FATF Travel Rule compliance."
+    )
+    args_schema: Type[BaseModel] = ComplianceInput if _LANGCHAIN_AVAILABLE else object  # type: ignore
+
+    def _run(self, address: str) -> str:
+        _require_langchain()
+        with DPX() as dpx:
+            return json.dumps(dpx.screen(address), indent=2)
+
+    async def _arun(self, *args, **kwargs) -> str:
+        return self._run(*args, **kwargs)
+
+
+# ── Toolkit ────────────────────────────────────────────────────────────────────
+
+class DPXToolkit(BaseToolkit):
+    """
+    DPX LangChain Toolkit — full settlement lifecycle as LangChain tools.
+
+    Provides: dpx_quote, dpx_settle, dpx_oracle_status, dpx_esg_score, dpx_compliance_screen
+
+    LangChain Hub: untitledfinancial/dpx-toolkit
+    """
+
+    def get_tools(self) -> List[BaseTool]:
+        _require_langchain()
+        return [
+            DPXOracleTool(),
+            DPXEsgTool(),
+            DPXComplianceTool(),
+            DPXQuoteTool(),
+            DPXSettleTool(),
+        ]

dpx_sdk/tools/llamaindex.py

@@ -0,0 +1,201 @@
+"""
+DPX LlamaIndex ToolSpec
+
+Usage:
+    from dpx_sdk.tools import DPXToolSpec
+    from llama_index.agent.openai import OpenAIAgent   # or any agent
+
+    dpx_spec = DPXToolSpec()
+    tools = dpx_spec.to_tool_list()
+    agent = OpenAIAgent.from_tools(tools, verbose=True)
+    agent.chat("Get a quote for $1M USD to EUR and check oracle stability")
+
+LlamaIndex Hub: untitledfinancial/dpx-tool-spec
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+try:
+    from llama_index.core.tools import FunctionTool
+    from llama_index.core.tools.tool_spec.base import BaseToolSpec
+    _LLAMA_AVAILABLE = True
+except ImportError:
+    try:
+        from llama_index.tools import FunctionTool
+        from llama_index.tools.tool_spec.base import BaseToolSpec
+        _LLAMA_AVAILABLE = True
+    except ImportError:
+        _LLAMA_AVAILABLE = False
+        BaseToolSpec = object  # type: ignore
+
+from ..client import DPX
+
+
+def _require_llama():
+    if not _LLAMA_AVAILABLE:
+        raise ImportError("Install llama-index: pip install llama-index-core")
+
+
+class DPXToolSpec(BaseToolSpec):
+    """
+    DPX ToolSpec for LlamaIndex agents.
+
+    Exposes the full DPX settlement lifecycle:
+    - get_settlement_quote      — Binding fee quote
+    - execute_settlement        — Cross-border settlement execution
+    - get_oracle_status         — Macro stability assessment
+    - get_esg_score             — ESG counterparty scoring
+    - screen_compliance         — FATF/AML/sanctions screening
+    """
+
+    spec_functions = [
+        "get_settlement_quote",
+        "execute_settlement",
+        "get_oracle_status",
+        "get_esg_score",
+        "screen_compliance",
+    ]
+
+    def get_settlement_quote(
+        self,
+        amount_usd: float,
+        has_fx: bool = True,
+        esg_score: float = 75,
+    ) -> str:
+        """
+        Get a binding fee quote for a DPX settlement.
+
+        Args:
+            amount_usd: Settlement amount in USD.
+            has_fx: True if cross-currency (adds FX fee). Default True.
+            esg_score: Counterparty ESG score 0–100. Default 75.
+
+        Returns:
+            JSON string with quote_id, net_amount_usd, fee breakdown,
+            oracle_status, tier, and AI reasoning. Quote valid 300 seconds.
+        """
+        _require_llama()
+        with DPX() as dpx:
+            q = dpx.quote(amount_usd=amount_usd, has_fx=has_fx, esg_score=esg_score)
+        return json.dumps({
+            "quote_id": q.quote_id,
+            "amount_usd": q.amount_usd,
+            "net_amount_usd": q.net_amount_usd,
+            "total_fee_pct": q.total_fee_pct,
+            "total_fee_usd": q.total_fee_usd,
+            "oracle_status": q.oracle_status,
+            "tier": q.tier,
+            "expires_at": q.expires_at,
+            "reasoning": q.reasoning,
+        }, indent=2)
+
+    def execute_settlement(
+        self,
+        amount: float,
+        source_currency: str,
+        destination_currency: str,
+        recipient_address: str,
+        purpose: str = "vendor-payment",
+        sandbox: bool = True,
+    ) -> str:
+        """
+        Execute a DPX cross-border or domestic settlement.
+
+        Args:
+            amount: Settlement amount.
+            source_currency: USD, EUR, GBP, USDC, or EURC.
+            destination_currency: USD, EUR, GBP, USDC, or EURC.
+            recipient_address: On-chain recipient wallet address (0x...).
+            purpose: vendor-payment, intercompany, payroll, or treasury.
+            sandbox: If True (default), returns calculations without on-chain execution.
+                     Set False only for live execution with explicit user confirmation.
+
+        Returns:
+            JSON string with settlement_id, status, tx_hash, net_amount, fees, and reasoning.
+        """
+        _require_llama()
+        with DPX() as dpx:
+            r = dpx.settle(
+                amount=amount,
+                source_currency=source_currency,
+                destination_currency=destination_currency,
+                recipient_address=recipient_address,
+                purpose=purpose,
+                sandbox=sandbox,
+            )
+        return json.dumps({
+            "settlement_id": r.settlement_id,
+            "status": r.status,
+            "tx_hash": r.tx_hash,
+            "net_amount": r.net_amount,
+            "fees_total": r.fees_total,
+            "oracle_status": r.oracle_status,
+            "reasoning": r.reasoning,
+            "timestamp": r.timestamp,
+        }, indent=2)
+
+    def get_oracle_status(self) -> str:
+        """
+        Get live macro stability assessment from the DPX Stability Oracle.
+
+        Returns stability score (0–100), status (STABLE/CAUTION/UNSTABLE),
+        recommendation (PROCEED/CAUTION/HOLD), peg deviation in bps, outlook,
+        and AI reasoning. UNSTABLE means hold large settlements.
+        """
+        _require_llama()
+        with DPX() as dpx:
+            o = dpx.oracle_status()
+        return json.dumps({
+            "status": o.status,
+            "score": o.score,
+            "recommendation": o.recommendation,
+            "peg_deviation_bps": o.peg_deviation,
+            "outlook": o.outlook,
+            "reasoning": o.reasoning,
+        }, indent=2)
+
+    def get_esg_score(self, address: Optional[str] = None) -> str:
+        """
+        Get the ESG counterparty risk score for a wallet address.
+
+        Args:
+            address: Wallet address (0x...). Omit for protocol default score.
+
+        Returns:
+            JSON string with composite ESG score (0–100), E/S/G sub-scores,
+            settlement fee adjustment, and tier. Updated hourly from 6 institutional
+            sources: World Bank, IMF, OECD, UN, SEC, ClimateMonitor.
+            Required for EU SFDR PAI reporting and CSRD disclosure.
+        """
+        _require_llama()
+        with DPX() as dpx:
+            e = dpx.esg_score(address=address)
+        return json.dumps({
+            "address": e.address,
+            "esg_score": e.esg_score,
+            "environmental": e.environmental,
+            "social": e.social,
+            "governance": e.governance,
+            "fee_pct": e.fee_pct,
+            "tier": e.tier,
+        }, indent=2)
+
+    def screen_compliance(self, address: str) -> str:
+        """
+        Screen a counterparty through the DPX Compliance Oracle.
+
+        Args:
+            address: Wallet address or entity name to screen.
+
+        Returns:
+            JSON string with compliance decision (APPROVED/FLAGGED/BLOCKED),
+            FATF R16 Travel Rule status, AML signals, sanctions check,
+            MiCA and GENIUS Act attestations, and full reasoning.
+            Call before every settlement for FATF Travel Rule compliance.
+        """
+        _require_llama()
+        with DPX() as dpx:
+            return json.dumps(dpx.screen(address), indent=2)

dpx_sdk/types.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class FeeComponent:
+    pct: float
+    usd: float
+
+
+@dataclass
+class QuoteResult:
+    quote_id: str
+    amount_usd: float
+    net_amount_usd: float
+    total_fee_pct: float
+    total_fee_usd: float
+    oracle_status: str
+    oracle_score: float
+    tier: str
+    expires_at: str
+    reasoning: str
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class SettlementResult:
+    settlement_id: str
+    status: str          # executed | sandbox | held | failed
+    tx_hash: Optional[str]
+    net_amount: float
+    fees_total: float
+    oracle_status: str
+    reasoning: str
+    timestamp: str
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class OracleStatus:
+    status: str          # STABLE | CAUTION | UNSTABLE
+    score: float
+    recommendation: str  # PROCEED | CAUTION | HOLD
+    peg_deviation: float
+    outlook: str
+    reasoning: str
+    timestamp: str
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class EsgScore:
+    address: str
+    esg_score: float
+    environmental: float
+    social: float
+    governance: float
+    fee_pct: float
+    tier: str
+    updated_at: str
+    raw: dict = field(default_factory=dict)

dpx_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: dpx-sdk
+Version: 0.1.0
+Summary: Python SDK for the DPX Protocol — compliance-grade stablecoin settlement rail with LangChain and LlamaIndex toolkits
+Project-URL: Homepage, https://untitledfinancial.com
+Project-URL: Documentation, https://docs.untitledfinancial.com
+Project-URL: Repository, https://github.com/untitledfinancial/dpx-mcp
+License: BUSL-1.1
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: all
+Requires-Dist: langchain-core>=0.2.0; extra == 'all'
+Requires-Dist: langchain>=0.2.0; extra == 'all'
+Requires-Dist: llama-index-core>=0.10.0; extra == 'all'
+Requires-Dist: pydantic>=2.0; extra == 'all'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2.0; extra == 'langchain'
+Requires-Dist: langchain>=0.2.0; extra == 'langchain'
+Requires-Dist: pydantic>=2.0; extra == 'langchain'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10.0; extra == 'llamaindex'
+Description-Content-Type: text/markdown
+
+# dpx-sdk
+
+Python SDK for [DPX Protocol](https://untitledfinancial.com) — compliance-grade stablecoin settlement rail with native LangChain and LlamaIndex toolkits.
+
+```bash
+pip install dpx-sdk                      # core client
+pip install "dpx-sdk[langchain]"         # + LangChain toolkit
+pip install "dpx-sdk[llamaindex]"        # + LlamaIndex ToolSpec
+pip install "dpx-sdk[all]"              # everything
+```
+
+## Quick start
+
+```python
+from dpx_sdk import DPX
+
+with DPX() as dpx:
+    # Check oracle before settling
+    oracle = dpx.oracle_status()
+    print(oracle.status, oracle.recommendation)  # STABLE  PROCEED
+
+    # Get a binding quote
+    quote = dpx.quote(amount_usd=500_000, has_fx=True, esg_score=75)
+    print(f"Net: ${quote.net_amount_usd:,.2f}  Fee: {quote.total_fee_pct:.3f}%")
+
+    # Execute in sandbox (safe default)
+    result = dpx.settle(
+        amount=500_000,
+        source_currency="USD",
+        destination_currency="EUR",
+        recipient_address="0xYourRecipientAddress",
+        sandbox=True,  # set False for live execution
+    )
+    print(result.status, result.settlement_id)
+```
+
+## LangChain
+
+```python
+from dpx_sdk.tools import DPXToolkit
+from langchain.agents import initialize_agent, AgentType
+from langchain_openai import ChatOpenAI
+
+tools = DPXToolkit().get_tools()
+agent = initialize_agent(tools, ChatOpenAI(), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
+agent.run("Check oracle stability, get a quote for $1M USD→EUR, and screen the counterparty 0x123...")
+```
+
+Available tools: `dpx_oracle_status` · `dpx_esg_score` · `dpx_compliance_screen` · `dpx_quote` · `dpx_settle`
+
+**LangChain Hub:** `untitledfinancial/dpx-toolkit`
+
+## LlamaIndex
+
+```python
+from dpx_sdk.tools import DPXToolSpec
+from llama_index.agent.openai import OpenAIAgent
+
+tools = DPXToolSpec().to_tool_list()
+agent = OpenAIAgent.from_tools(tools, verbose=True)
+agent.chat("Get a quote for $500K USD to EUR and execute in sandbox mode")
+```
+
+Available functions: `get_settlement_quote` · `execute_settlement` · `get_oracle_status` · `get_esg_score` · `screen_compliance`
+
+**LlamaIndex Hub:** `untitledfinancial/dpx-tool-spec`
+
+## MCP (Claude / Cursor)
+
+```bash
+npx @untitledfinancial/dpx-mcp
+```
+
+32 MCP tools for Claude Desktop and Cursor. [Setup →](https://docs.untitledfinancial.com/integrations/mcp)
+
+## Links
+
+- [Documentation](https://docs.untitledfinancial.com)
+- [MCP on Smithery](https://smithery.ai/server/@untitledfinancial/dpx-mcp)
+- [npm package](https://www.npmjs.com/package/@untitledfinancial/dpx-mcp)
+- [Contracts on Base mainnet](https://base.blockscout.com/address/0xe333551E18ef0471A71d7e8e761212766aa5AD4f)

dpx_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dpx_sdk/__init__.py,sha256=x7jKK0dYRs24Fzr_xIDqHGejafqsYXt9L0BfjqBNVtc,223
+dpx_sdk/client.py,sha256=Lq7qQW6OkooAlS5DmldCLEzAbeo_Ribgj9ipGJXbTCM,5587
+dpx_sdk/types.py,sha256=5JNanNtglsUnSKiy0-wQQBeA56nrfHK-7Kv1F1zqlNA,1232
+dpx_sdk/tools/__init__.py,sha256=oIUGq4HTGjm0ortRNu18AaFs7PZwX_Z90lOQwc39ZnM,302
+dpx_sdk/tools/langchain.py,sha256=TwYdDZ6QroJWbBvO8_LwgKKCYI1-WFuKMLBZ0FJZzoA,9441
+dpx_sdk/tools/llamaindex.py,sha256=Tzu4Dj6g54eM-45DjGBdilcRHQswBxLtVaC9DI5lpnA,6839
+dpx_sdk-0.1.0.dist-info/METADATA,sha256=Eh4MtKn6JlDngMIInPiWyD77vhjS5-wCh5ZJTemYrDM,3632
+dpx_sdk-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dpx_sdk-0.1.0.dist-info/RECORD,,

dpx_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any