proofgate 0.1.0__py3-none-any.whl

proofgate/__init__.py

@@ -0,0 +1,51 @@
+"""
+ProofGate SDK
+
+Blockchain guardrails for AI agents. Validate transactions
+before execution to prevent wallet drains, infinite approvals,
+and other security risks.
+
+Example:
+    >>> from proofgate import ProofGate
+    >>> 
+    >>> pg = ProofGate(api_key="pg_your_key")
+    >>> 
+    >>> result = await pg.validate(
+    ...     from_address="0xAgent...",
+    ...     to="0xContract...",
+    ...     data="0xa9059cbb...",
+    ... )
+    >>> 
+    >>> if result.safe:
+    ...     # Execute transaction
+    ...     pass
+    ... else:
+    ...     print(f"Blocked: {result.reason}")
+"""
+
+from proofgate.client import ProofGate, AsyncProofGate
+from proofgate.types import (
+    ProofGateConfig,
+    ValidateRequest,
+    ValidateResponse,
+    ValidationCheck,
+    AgentCheckResponse,
+    EvidenceResponse,
+    UsageResponse,
+)
+from proofgate.exceptions import ProofGateError
+
+__all__ = [
+    "ProofGate",
+    "AsyncProofGate",
+    "ProofGateConfig",
+    "ValidateRequest",
+    "ValidateResponse",
+    "ValidationCheck",
+    "AgentCheckResponse",
+    "EvidenceResponse",
+    "UsageResponse",
+    "ProofGateError",
+]
+
+__version__ = "0.1.0"

proofgate/client.py

@@ -0,0 +1,524 @@
+"""ProofGate SDK Client implementations."""
+
+from typing import Optional, Dict, Any
+import httpx
+
+from proofgate.types import (
+    ProofGateConfig,
+    ValidateRequest,
+    ValidateResponse,
+    AgentCheckResponse,
+    EvidenceResponse,
+    UsageResponse,
+)
+from proofgate.exceptions import ProofGateError
+
+
+class AsyncProofGate:
+    """Async ProofGate SDK Client.
+    
+    Example:
+        >>> from proofgate import AsyncProofGate
+        >>> 
+        >>> pg = AsyncProofGate(api_key="pg_your_key")
+        >>> 
+        >>> result = await pg.validate(
+        ...     from_address="0xAgent...",
+        ...     to="0xContract...",
+        ...     data="0xa9059cbb...",
+        ... )
+        >>> 
+        >>> if result.safe:
+        ...     # Execute transaction
+        ...     pass
+    """
+    
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://www.proofgate.xyz/api",
+        chain_id: int = 56,
+        guardrail_id: Optional[str] = None,
+        timeout: float = 30.0,
+    ):
+        """Initialize ProofGate client.
+        
+        Args:
+            api_key: API key from ProofGate dashboard (starts with pg_)
+            base_url: Base URL for API (default: https://www.proofgate.xyz/api)
+            chain_id: Default chain ID (default: 56 for BSC)
+            guardrail_id: Default guardrail ID to use for validations
+            timeout: Request timeout in seconds (default: 30.0)
+        """
+        if not api_key:
+            raise ProofGateError(
+                "API key is required. Get one at https://www.proofgate.xyz/dashboard",
+                "MISSING_API_KEY",
+            )
+        
+        if not api_key.startswith("pg_"):
+            raise ProofGateError(
+                'Invalid API key format. Keys start with "pg_"',
+                "INVALID_API_KEY",
+            )
+        
+        self.config = ProofGateConfig(
+            api_key=api_key,
+            base_url=base_url,
+            chain_id=chain_id,
+            guardrail_id=guardrail_id,
+            timeout=timeout,
+        )
+        
+        self._client = httpx.AsyncClient(
+            base_url=base_url,
+            timeout=timeout,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+            },
+        )
+    
+    async def __aenter__(self) -> "AsyncProofGate":
+        return self
+    
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+    
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self._client.aclose()
+    
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make an API request."""
+        try:
+            response = await self._client.request(method, path, json=json)
+            data = response.json()
+            
+            if not response.is_success:
+                raise ProofGateError(
+                    data.get("error") or data.get("message") or f"HTTP {response.status_code}",
+                    "API_ERROR",
+                    response.status_code,
+                )
+            
+            return data
+            
+        except httpx.TimeoutException:
+            raise ProofGateError("Request timeout", "TIMEOUT")
+        except httpx.RequestError as e:
+            raise ProofGateError(str(e), "NETWORK_ERROR")
+    
+    async def validate(
+        self,
+        from_address: str,
+        to: str,
+        data: str,
+        value: str = "0",
+        guardrail_id: Optional[str] = None,
+        chain_id: Optional[int] = None,
+    ) -> ValidateResponse:
+        """Validate a transaction before execution.
+        
+        Args:
+            from_address: Sender address (your agent's wallet)
+            to: Target contract address
+            data: Transaction calldata
+            value: Value in wei (default: "0")
+            guardrail_id: Guardrail ID (overrides default)
+            chain_id: Chain ID (overrides default)
+        
+        Returns:
+            Validation result
+        
+        Example:
+            >>> result = await pg.validate(
+            ...     from_address="0xAgent...",
+            ...     to="0xUniswap...",
+            ...     data="0x38ed1739...",  # swap calldata
+            ... )
+            >>> 
+            >>> if result.safe:
+            ...     # Execute the swap
+            ...     pass
+            >>> else:
+            ...     print(f"Blocked: {result.reason}")
+        """
+        response = await self._request(
+            "POST",
+            "/validate",
+            json={
+                "from": from_address,
+                "to": to,
+                "data": data,
+                "value": value,
+                "guardrailId": guardrail_id or self.config.guardrail_id,
+                "chainId": chain_id or self.config.chain_id,
+            },
+        )
+        return ValidateResponse.model_validate(response)
+    
+    async def validate_or_throw(
+        self,
+        from_address: str,
+        to: str,
+        data: str,
+        value: str = "0",
+        guardrail_id: Optional[str] = None,
+        chain_id: Optional[int] = None,
+    ) -> ValidateResponse:
+        """Validate and throw if unsafe (convenience method).
+        
+        Args:
+            from_address: Sender address (your agent's wallet)
+            to: Target contract address
+            data: Transaction calldata
+            value: Value in wei (default: "0")
+            guardrail_id: Guardrail ID (overrides default)
+            chain_id: Chain ID (overrides default)
+        
+        Returns:
+            Validation result (only if safe)
+        
+        Raises:
+            ProofGateError: If validation fails
+        
+        Example:
+            >>> try:
+            ...     await pg.validate_or_throw(from_address, to, data)
+            ...     # Safe to execute
+            ...     await wallet.send_transaction(to=to, data=data)
+            ... except ProofGateError as e:
+            ...     print(f"Blocked: {e.message}")
+        """
+        result = await self.validate(
+            from_address=from_address,
+            to=to,
+            data=data,
+            value=value,
+            guardrail_id=guardrail_id,
+            chain_id=chain_id,
+        )
+        
+        if not result.safe:
+            raise ProofGateError(
+                result.reason,
+                "VALIDATION_FAILED",
+                validation_result=result,
+            )
+        
+        return result
+    
+    async def check_agent(self, wallet: str) -> AgentCheckResponse:
+        """Check an agent's trust score and verification status.
+        
+        Args:
+            wallet: Agent wallet address
+        
+        Returns:
+            Agent verification info
+        
+        Example:
+            >>> agent = await pg.check_agent("0x123...")
+            >>> 
+            >>> if agent.verification_status == "verified":
+            ...     print(f"Trusted agent: {agent.tier_emoji} {agent.trust_score}/100")
+            >>> else:
+            ...     print("Warning: Unverified agent")
+        """
+        response = await self._request("GET", f"/agents/check?wallet={wallet}")
+        return AgentCheckResponse.model_validate(response)
+    
+    async def get_evidence(self, validation_id: str) -> EvidenceResponse:
+        """Get evidence for a past validation.
+        
+        Args:
+            validation_id: Validation ID
+        
+        Returns:
+            Evidence details
+        
+        Example:
+            >>> evidence = await pg.get_evidence("val_abc123")
+            >>> print(evidence.transaction)
+            >>> print(evidence.result)
+        """
+        response = await self._request("GET", f"/evidence/{validation_id}")
+        return EvidenceResponse.model_validate(response)
+    
+    async def get_usage(self, wallet: str) -> UsageResponse:
+        """Get validation usage stats for a wallet.
+        
+        Args:
+            wallet: Wallet address
+        
+        Returns:
+            Usage statistics
+        """
+        response = await self._request("GET", f"/validate?wallet={wallet}")
+        return UsageResponse.model_validate(response)
+
+
+class ProofGate:
+    """Synchronous ProofGate SDK Client.
+    
+    Uses httpx sync client under the hood. For async applications,
+    use AsyncProofGate instead.
+    
+    Example:
+        >>> from proofgate import ProofGate
+        >>> 
+        >>> pg = ProofGate(api_key="pg_your_key")
+        >>> 
+        >>> result = pg.validate(
+        ...     from_address="0xAgent...",
+        ...     to="0xContract...",
+        ...     data="0xa9059cbb...",
+        ... )
+        >>> 
+        >>> if result.safe:
+        ...     # Execute transaction
+        ...     pass
+    """
+    
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://www.proofgate.xyz/api",
+        chain_id: int = 56,
+        guardrail_id: Optional[str] = None,
+        timeout: float = 30.0,
+    ):
+        """Initialize ProofGate client.
+        
+        Args:
+            api_key: API key from ProofGate dashboard (starts with pg_)
+            base_url: Base URL for API (default: https://www.proofgate.xyz/api)
+            chain_id: Default chain ID (default: 56 for BSC)
+            guardrail_id: Default guardrail ID to use for validations
+            timeout: Request timeout in seconds (default: 30.0)
+        """
+        if not api_key:
+            raise ProofGateError(
+                "API key is required. Get one at https://www.proofgate.xyz/dashboard",
+                "MISSING_API_KEY",
+            )
+        
+        if not api_key.startswith("pg_"):
+            raise ProofGateError(
+                'Invalid API key format. Keys start with "pg_"',
+                "INVALID_API_KEY",
+            )
+        
+        self.config = ProofGateConfig(
+            api_key=api_key,
+            base_url=base_url,
+            chain_id=chain_id,
+            guardrail_id=guardrail_id,
+            timeout=timeout,
+        )
+        
+        self._client = httpx.Client(
+            base_url=base_url,
+            timeout=timeout,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+            },
+        )
+    
+    def __enter__(self) -> "ProofGate":
+        return self
+    
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+    
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+    
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make an API request."""
+        try:
+            response = self._client.request(method, path, json=json)
+            data = response.json()
+            
+            if not response.is_success:
+                raise ProofGateError(
+                    data.get("error") or data.get("message") or f"HTTP {response.status_code}",
+                    "API_ERROR",
+                    response.status_code,
+                )
+            
+            return data
+            
+        except httpx.TimeoutException:
+            raise ProofGateError("Request timeout", "TIMEOUT")
+        except httpx.RequestError as e:
+            raise ProofGateError(str(e), "NETWORK_ERROR")
+    
+    def validate(
+        self,
+        from_address: str,
+        to: str,
+        data: str,
+        value: str = "0",
+        guardrail_id: Optional[str] = None,
+        chain_id: Optional[int] = None,
+    ) -> ValidateResponse:
+        """Validate a transaction before execution.
+        
+        Args:
+            from_address: Sender address (your agent's wallet)
+            to: Target contract address
+            data: Transaction calldata
+            value: Value in wei (default: "0")
+            guardrail_id: Guardrail ID (overrides default)
+            chain_id: Chain ID (overrides default)
+        
+        Returns:
+            Validation result
+        """
+        response = self._request(
+            "POST",
+            "/validate",
+            json={
+                "from": from_address,
+                "to": to,
+                "data": data,
+                "value": value,
+                "guardrailId": guardrail_id or self.config.guardrail_id,
+                "chainId": chain_id or self.config.chain_id,
+            },
+        )
+        return ValidateResponse.model_validate(response)
+    
+    def validate_or_throw(
+        self,
+        from_address: str,
+        to: str,
+        data: str,
+        value: str = "0",
+        guardrail_id: Optional[str] = None,
+        chain_id: Optional[int] = None,
+    ) -> ValidateResponse:
+        """Validate and throw if unsafe (convenience method).
+        
+        Args:
+            from_address: Sender address (your agent's wallet)
+            to: Target contract address
+            data: Transaction calldata
+            value: Value in wei (default: "0")
+            guardrail_id: Guardrail ID (overrides default)
+            chain_id: Chain ID (overrides default)
+        
+        Returns:
+            Validation result (only if safe)
+        
+        Raises:
+            ProofGateError: If validation fails
+        """
+        result = self.validate(
+            from_address=from_address,
+            to=to,
+            data=data,
+            value=value,
+            guardrail_id=guardrail_id,
+            chain_id=chain_id,
+        )
+        
+        if not result.safe:
+            raise ProofGateError(
+                result.reason,
+                "VALIDATION_FAILED",
+                validation_result=result,
+            )
+        
+        return result
+    
+    def check_agent(self, wallet: str) -> AgentCheckResponse:
+        """Check an agent's trust score and verification status.
+        
+        Args:
+            wallet: Agent wallet address
+        
+        Returns:
+            Agent verification info
+        """
+        response = self._request("GET", f"/agents/check?wallet={wallet}")
+        return AgentCheckResponse.model_validate(response)
+    
+    def get_evidence(self, validation_id: str) -> EvidenceResponse:
+        """Get evidence for a past validation.
+        
+        Args:
+            validation_id: Validation ID
+        
+        Returns:
+            Evidence details
+        """
+        response = self._request("GET", f"/evidence/{validation_id}")
+        return EvidenceResponse.model_validate(response)
+    
+    def get_usage(self, wallet: str) -> UsageResponse:
+        """Get validation usage stats for a wallet.
+        
+        Args:
+            wallet: Wallet address
+        
+        Returns:
+            Usage statistics
+        """
+        response = self._request("GET", f"/validate?wallet={wallet}")
+        return UsageResponse.model_validate(response)
+
+
+def is_transaction_safe(
+    api_key: str,
+    from_address: str,
+    to: str,
+    data: str,
+    value: str = "0",
+) -> bool:
+    """Quick validation helper.
+    
+    Args:
+        api_key: ProofGate API key
+        from_address: Sender address
+        to: Target contract address
+        data: Transaction calldata
+        value: Value in wei (default: "0")
+    
+    Returns:
+        Whether the transaction is safe
+    
+    Example:
+        >>> from proofgate import is_transaction_safe
+        >>> 
+        >>> safe = is_transaction_safe(
+        ...     "pg_xxx",
+        ...     from_address=agent,
+        ...     to=contract,
+        ...     data=calldata,
+        ... )
+    """
+    with ProofGate(api_key=api_key) as pg:
+        result = pg.validate(
+            from_address=from_address,
+            to=to,
+            data=data,
+            value=value,
+        )
+        return result.safe

proofgate/exceptions.py

@@ -0,0 +1,36 @@
+"""Exceptions for ProofGate SDK."""
+
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from proofgate.types import ValidateResponse
+
+
+class ProofGateError(Exception):
+    """Base exception for ProofGate errors.
+    
+    Attributes:
+        message: Human-readable error message
+        code: Error code (e.g., 'VALIDATION_FAILED', 'API_ERROR')
+        status_code: HTTP status code (if applicable)
+        validation_result: Validation result (if validation failed)
+    """
+    
+    def __init__(
+        self,
+        message: str,
+        code: str,
+        status_code: Optional[int] = None,
+        validation_result: Optional["ValidateResponse"] = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.status_code = status_code
+        self.validation_result = validation_result
+    
+    def __str__(self) -> str:
+        return f"[{self.code}] {self.message}"
+    
+    def __repr__(self) -> str:
+        return f"ProofGateError(code={self.code!r}, message={self.message!r})"

proofgate/types.py

@@ -0,0 +1,179 @@
+"""Type definitions for ProofGate SDK."""
+
+from typing import Optional, List, Literal
+from pydantic import BaseModel, Field
+
+
+class ProofGateConfig(BaseModel):
+    """Configuration for ProofGate client."""
+    
+    api_key: str = Field(..., description="API key from ProofGate dashboard (starts with pg_)")
+    base_url: str = Field(
+        default="https://www.proofgate.xyz/api",
+        description="Base URL for API"
+    )
+    chain_id: int = Field(default=56, description="Default chain ID (56 = BSC)")
+    guardrail_id: Optional[str] = Field(
+        default=None,
+        description="Default guardrail ID to use for validations"
+    )
+    timeout: float = Field(default=30.0, description="Request timeout in seconds")
+
+
+class ValidateRequest(BaseModel):
+    """Request for transaction validation."""
+    
+    from_address: str = Field(..., alias="from", description="Sender address (your agent's wallet)")
+    to: str = Field(..., description="Target contract address")
+    data: str = Field(..., description="Transaction calldata")
+    value: str = Field(default="0", description="Value in wei")
+    guardrail_id: Optional[str] = Field(default=None, description="Guardrail ID (overrides default)")
+    chain_id: Optional[int] = Field(default=None, description="Chain ID (overrides default)")
+
+    class Config:
+        populate_by_name = True
+
+
+class ValidationCheck(BaseModel):
+    """Individual check result from validation."""
+    
+    name: str = Field(..., description="Check name (e.g., 'allowed_contracts', 'daily_limit')")
+    passed: bool = Field(..., description="Did this check pass?")
+    details: str = Field(..., description="Human-readable details")
+    severity: Literal["info", "warning", "critical"] = Field(
+        ..., description="Severity level"
+    )
+
+
+class ValidateResponse(BaseModel):
+    """Response from transaction validation."""
+    
+    validation_id: str = Field(..., alias="validationId", description="Unique validation ID")
+    result: Literal["PASS", "FAIL", "PENDING"] = Field(..., description="Validation result")
+    reason: str = Field(..., description="Human-readable reason")
+    evidence_uri: str = Field(..., alias="evidenceUri", description="Evidence URI")
+    safe: bool = Field(..., description="Is the transaction safe to execute?")
+    checks: List[ValidationCheck] = Field(default_factory=list, description="Detailed check results")
+    chain_id: int = Field(..., alias="chainId", description="Chain ID validated on")
+    authenticated: bool = Field(default=False, description="Was API key authenticated?")
+    tier: str = Field(default="free", description="User tier (free/pro)")
+    backend: str = Field(default="local", description="Backend used (local/evidence-service)")
+    on_chain_recorded: bool = Field(
+        default=False, alias="onChainRecorded", description="Was proof recorded on-chain?"
+    )
+
+    class Config:
+        populate_by_name = True
+
+
+class AgentStats(BaseModel):
+    """Validation statistics for an agent."""
+    
+    total_validations: int = Field(..., alias="totalValidations")
+    passed_validations: int = Field(..., alias="passedValidations")
+    failed_validations: int = Field(..., alias="failedValidations")
+    pass_rate: float = Field(..., alias="passRate")
+
+    class Config:
+        populate_by_name = True
+
+
+class AgentRegistration(BaseModel):
+    """Registration info for an agent."""
+    
+    name: Optional[str] = None
+    registered_at: str = Field(..., alias="registeredAt")
+
+    class Config:
+        populate_by_name = True
+
+
+class AgentCheckResponse(BaseModel):
+    """Response from agent check."""
+    
+    wallet: str = Field(..., description="Wallet address (lowercase)")
+    is_registered: bool = Field(..., alias="isRegistered", description="Is this agent registered?")
+    verification_status: Literal["verified", "registered", "unverified", "unknown"] = Field(
+        ..., alias="verificationStatus", description="Verification status"
+    )
+    verification_message: str = Field(..., alias="verificationMessage", description="Human-readable message")
+    trust_score: int = Field(..., alias="trustScore", description="Trust score (0-100)")
+    tier: Literal["diamond", "gold", "silver", "bronze", "unverified"] = Field(
+        ..., description="Trust tier"
+    )
+    tier_emoji: str = Field(..., alias="tierEmoji", description="Tier emoji")
+    tier_name: str = Field(..., alias="tierName", description="Tier display name")
+    stats: AgentStats = Field(..., description="Validation statistics")
+    registration: Optional[AgentRegistration] = Field(
+        default=None, description="Registration info (if registered)"
+    )
+    recommendation: str = Field(..., description="Safety recommendation")
+
+    class Config:
+        populate_by_name = True
+
+
+class EvidenceTransaction(BaseModel):
+    """Transaction details in evidence."""
+    
+    from_address: str = Field(..., alias="from")
+    to: str
+    data: str
+    value: str
+
+    class Config:
+        populate_by_name = True
+
+
+class EvidenceResult(BaseModel):
+    """Validation result in evidence."""
+    
+    status: Literal["PASS", "FAIL", "PENDING"]
+    reason: str
+    safe: bool
+
+
+class EvidenceAgent(BaseModel):
+    """Agent info in evidence."""
+    
+    wallet: str
+    name: Optional[str] = None
+    verified: bool
+
+
+class EvidenceProof(BaseModel):
+    """Proof metadata in evidence."""
+    
+    authenticated: bool
+    on_chain_recorded: bool = Field(..., alias="onChainRecorded")
+    batch_id: Optional[str] = Field(default=None, alias="batchId")
+    recorded_at: Optional[str] = Field(default=None, alias="recordedAt")
+
+    class Config:
+        populate_by_name = True
+
+
+class EvidenceResponse(BaseModel):
+    """Response from evidence retrieval."""
+    
+    validation_id: str = Field(..., alias="validationId", description="Validation ID")
+    timestamp: str = Field(..., description="Timestamp")
+    chain_id: int = Field(..., alias="chainId", description="Chain ID")
+    transaction: EvidenceTransaction = Field(..., description="Transaction details")
+    result: EvidenceResult = Field(..., description="Validation result")
+    guardrail_id: Optional[str] = Field(default=None, alias="guardrailId", description="Guardrail used")
+    agent: EvidenceAgent = Field(..., description="Agent info")
+    proof: EvidenceProof = Field(..., description="Proof metadata")
+
+    class Config:
+        populate_by_name = True
+
+
+class UsageResponse(BaseModel):
+    """Response from usage check."""
+    
+    wallet: str
+    tier: str
+    validations_used: int
+    validations_limit: int
+    daily_spent_wei: str

proofgate-0.1.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: proofgate
+Version: 0.1.0
+Summary: Official ProofGate SDK — blockchain transaction validation and guardrails for AI agents
+Project-URL: Homepage, https://www.proofgate.xyz
+Project-URL: Documentation, https://www.proofgate.xyz/docs
+Project-URL: Repository, https://github.com/ProofGate/proofgate-python
+Project-URL: Issues, https://github.com/ProofGate/proofgate-python/issues
+Author-email: 0xCR6 <cristian@proofgate.xyz>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agent,blockchain,bsc,defi,ethereum,guardrails,proofgate,security,validation,web3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# proofgate
+
+> Blockchain guardrails for AI agents. Validate transactions before execution.
+
+[![PyPI version](https://badge.fury.io/py/proofgate.svg)](https://pypi.org/project/proofgate/)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What is ProofGate?
+
+ProofGate validates blockchain transactions before your AI agent executes them. It prevents:
+
+- 🚫 **Wallet drains** from prompt injection attacks
+- 🚫 **Infinite approvals** to malicious contracts  
+- 🚫 **Excessive spending** beyond daily limits
+- 🚫 **High slippage** swaps that lose money
+
+## Installation
+
+```bash
+pip install proofgate
+```
+
+## Quick Start
+
+### Synchronous Usage
+
+```python
+from proofgate import ProofGate
+
+# Initialize client
+pg = ProofGate(api_key="pg_your_api_key")  # Get from proofgate.xyz/dashboard
+
+# Validate before sending
+result = pg.validate(
+    from_address="0xYourAgentWallet",
+    to="0xContractAddress",
+    data="0xa9059cbb...",  # Transaction calldata
+    value="0",
+)
+
+if result.safe:
+    # ✅ Execute the transaction
+    wallet.send_transaction(to=to, data=data, value=value)
+else:
+    # 🚫 Transaction blocked
+    print(f"Blocked: {result.reason}")
+```
+
+### Async Usage
+
+```python
+from proofgate import AsyncProofGate
+
+async def main():
+    async with AsyncProofGate(api_key="pg_your_api_key") as pg:
+        result = await pg.validate(
+            from_address="0xYourAgentWallet",
+            to="0xContractAddress",
+            data="0xa9059cbb...",
+        )
+        
+        if result.safe:
+            # Execute transaction
+            pass
+```
+
+## API Reference
+
+### `ProofGate(config)` / `AsyncProofGate(config)`
+
+Create a new ProofGate client.
+
+```python
+pg = ProofGate(
+    api_key="pg_xxx",           # Required: Your API key
+    chain_id=56,                 # Optional: Default chain (56 = BSC)
+    guardrail_id="xxx",          # Optional: Default guardrail
+    base_url="https://...",      # Optional: Custom API URL
+    timeout=30.0,                # Optional: Request timeout (seconds)
+)
+```
+
+### `pg.validate(request)`
+
+Validate a transaction.
+
+```python
+result = pg.validate(
+    from_address="0xAgent...",
+    to="0xContract...",
+    data="0x...",
+    value="0",           # Optional
+    guardrail_id="xxx",  # Optional: Override default
+    chain_id=56,         # Optional: Override default
+)
+
+# Returns ValidateResponse with:
+# - validation_id: str
+# - result: "PASS" | "FAIL" | "PENDING"
+# - reason: str
+# - safe: bool
+# - checks: List[ValidationCheck]
+# - authenticated: bool
+# - evidence_uri: str
+```
+
+### `pg.validate_or_throw(request)`
+
+Validate and raise exception if unsafe.
+
+```python
+from proofgate import ProofGateError
+
+try:
+    pg.validate_or_throw(
+        from_address=from_addr,
+        to=to_addr,
+        data=calldata,
+    )
+    # Safe to execute
+except ProofGateError as e:
+    print(f"Blocked: {e.message}")
+```
+
+### `pg.check_agent(wallet)`
+
+Check an agent's trust score.
+
+```python
+agent = pg.check_agent("0x123...")
+
+print(agent.trust_score)         # 85
+print(agent.tier)                # "gold"
+print(agent.verification_status) # "verified"
+```
+
+### `pg.get_evidence(validation_id)`
+
+Get evidence for a past validation.
+
+```python
+evidence = pg.get_evidence("val_abc123")
+print(evidence.transaction)
+print(evidence.result)
+```
+
+## Guardrails
+
+Guardrails define what your agent can do. Create them at [proofgate.xyz/guardrails](https://www.proofgate.xyz/guardrails).
+
+Example guardrail rules:
+- **Whitelist contracts**: Only Uniswap, Aave, Compound
+- **Max approval**: 1,000 USDC per approval
+- **Max slippage**: 1% on swaps
+- **Daily limit**: $10,000 total spending
+
+## Error Handling
+
+```python
+from proofgate import ProofGate, ProofGateError
+
+try:
+    pg.validate(from_address=from_addr, to=to_addr, data=calldata)
+except ProofGateError as e:
+    print(f"Code: {e.code}")          # "VALIDATION_FAILED"
+    print(f"Message: {e.message}")    # "Infinite approval detected"
+    print(f"Result: {e.validation_result}")
+```
+
+Error codes:
+- `MISSING_API_KEY` - No API key provided
+- `INVALID_API_KEY` - Key doesn't start with `pg_`
+- `VALIDATION_FAILED` - Transaction failed validation
+- `API_ERROR` - API returned an error
+- `NETWORK_ERROR` - Network request failed
+- `TIMEOUT` - Request timed out
+
+## Type Hints
+
+Full type hints included:
+
+```python
+from proofgate import (
+    ProofGateConfig,
+    ValidateRequest,
+    ValidateResponse,
+    ValidationCheck,
+    AgentCheckResponse,
+    EvidenceResponse,
+)
+```
+
+## Get Your API Key
+
+1. Go to [proofgate.xyz](https://www.proofgate.xyz)
+2. Connect your wallet
+3. Register your AI agent
+4. Copy your API key (starts with `pg_`)
+
+**Free tier:** 100 validations/month
+
+## Links
+
+- **Website:** [proofgate.xyz](https://www.proofgate.xyz)
+- **Documentation:** [proofgate.xyz/docs](https://www.proofgate.xyz/docs)
+- **Dashboard:** [proofgate.xyz/dashboard](https://www.proofgate.xyz/dashboard)
+- **GitHub:** [github.com/ProofGate/proofgate-python](https://github.com/ProofGate/proofgate-python)
+
+## License
+
+MIT © [0xCR6](https://twitter.com/0xCR6)

proofgate-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+proofgate/__init__.py,sha256=RYOe5gCXPhsPG6-HzsnmVkdWpzE6GoIHimcZ4J9sdTE,1130
+proofgate/client.py,sha256=nnCqjtD12WXU5u1dzkx6VEMxnAYiZgJ-9HSFrPdl0Fs,15765
+proofgate/exceptions.py,sha256=PCbAa3hHlNvG0seXRl0j1ubbi6PGLJHyIdEE8tb0bpo,1059
+proofgate/types.py,sha256=RPJPHlyi1NZ31MoLntoXlUb8S_EpdVCKbg9MQQj6XnY,6588
+proofgate-0.1.0.dist-info/METADATA,sha256=oe1bbnV56br6ryNBiWfqYasIi7CcYVN9oxTorQ6qi2E,6817
+proofgate-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+proofgate-0.1.0.dist-info/licenses/LICENSE,sha256=Z3Jp3T7pcPkUZiJK7_WuigXNQZYY_bpasmJg1mS9NA8,1062
+proofgate-0.1.0.dist-info/RECORD,,

proofgate-0.1.0.dist-info/WHEEL

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

proofgate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 0xCR6
+
+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.