proofgate-agentkit 0.1.0__py3-none-any.whl

proofgate_agentkit/__init__.py

@@ -0,0 +1,30 @@
+"""ProofGate Action Provider for Coinbase AgentKit.
+
+Blockchain guardrails for AI agents - validate transactions before execution.
+"""
+
+from .action_provider import (
+    ProofGateActionProvider,
+    proofgate_action_provider,
+)
+from .config import ProofGateConfig
+from .exceptions import ProofGateValidationError
+from .wrapper import (
+    ProofGateWrapper,
+    wrap_with_proofgate,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Action Provider
+    "ProofGateActionProvider",
+    "proofgate_action_provider",
+    # Config
+    "ProofGateConfig",
+    # Wrapper
+    "ProofGateWrapper",
+    "wrap_with_proofgate",
+    # Exceptions
+    "ProofGateValidationError",
+]

proofgate_agentkit/action_provider.py

@@ -0,0 +1,311 @@
+"""ProofGate Action Provider for Coinbase AgentKit.
+
+This module provides the ProofGateActionProvider class that validates
+transactions through ProofGate before they are executed.
+"""
+
+import logging
+from typing import Any, Optional
+
+from coinbase_agentkit.action_providers import ActionProvider, create_action
+from coinbase_agentkit.network import Network
+from coinbase_agentkit.wallet_providers import EvmWalletProvider
+from proofgate import ProofGate, ProofGateError
+from pydantic import BaseModel, Field
+
+from .config import ProofGateConfig
+from .exceptions import ProofGateValidationError
+
+logger = logging.getLogger(__name__)
+
+
+class ValidateTransactionSchema(BaseModel):
+    """Schema for validating a transaction through ProofGate."""
+
+    to: str = Field(..., description="The destination address of the transaction")
+    data: str = Field(default="0x", description="The transaction calldata (hex)")
+    value: str = Field(default="0", description="The value to send in wei")
+    guardrail_id: Optional[str] = Field(None, description="Override guardrail ID")
+
+
+class CheckAgentSchema(BaseModel):
+    """Schema for checking an agent's trust score."""
+
+    wallet_address: str = Field(..., description="The wallet address to check")
+
+
+class ProofGateActionProvider(ActionProvider[EvmWalletProvider]):
+    """Action provider that validates transactions through ProofGate.
+
+    ProofGate acts as a security layer that validates blockchain transactions
+    before execution, protecting AI agents from:
+    - Wallet drains from prompt injection attacks
+    - Infinite token approvals to malicious contracts
+    - Excessive spending beyond limits
+    - High slippage swaps
+
+    Example:
+        ```python
+        from proofgate_agentkit import ProofGateActionProvider, ProofGateConfig
+
+        config = ProofGateConfig(
+            api_key="pg_your_api_key",
+            guardrail_id="your_guardrail_id",
+        )
+        provider = ProofGateActionProvider(config)
+        ```
+    """
+
+    def __init__(
+        self,
+        config: ProofGateConfig,
+        action_providers: Optional[list[ActionProvider]] = None,
+    ) -> None:
+        """Initialize the ProofGate action provider.
+
+        Args:
+            config: ProofGate configuration with API credentials.
+            action_providers: Optional list of sub-providers.
+        """
+        super().__init__("proofgate", action_providers or [])
+        self.config = config
+
+        # Initialize ProofGate client
+        self._client = ProofGate(
+            api_key=config.api_key,
+            chain_id=config.chain_id,
+            guardrail_id=config.guardrail_id,
+            base_url=config.base_url,
+            timeout=config.timeout,
+        )
+
+    @property
+    def client(self) -> ProofGate:
+        """Get the ProofGate client."""
+        return self._client
+
+    def validate_transaction(
+        self,
+        from_address: str,
+        to: str,
+        data: str = "0x",
+        value: str = "0",
+        chain_id: Optional[int] = None,
+        guardrail_id: Optional[str] = None,
+    ) -> str:
+        """Validate a transaction through ProofGate.
+
+        Args:
+            from_address: The sender address.
+            to: The destination address.
+            data: Transaction calldata (hex).
+            value: Value in wei.
+            chain_id: Override chain ID.
+            guardrail_id: Override guardrail ID.
+
+        Returns:
+            The validation/proof ID if transaction is safe.
+
+        Raises:
+            ProofGateValidationError: If transaction is blocked.
+        """
+        try:
+            result = self._client.validate(
+                from_address=from_address,
+                to=to,
+                data=data,
+                value=value,
+                chain_id=chain_id,
+                guardrail_id=guardrail_id,
+            )
+
+            if self.config.log_validations:
+                logger.info(
+                    f"ProofGate validation: {result.result} | "
+                    f"ID: {result.validation_id} | "
+                    f"To: {to}"
+                )
+
+            if not result.safe:
+                raise ProofGateValidationError(
+                    message=f"Transaction blocked by ProofGate: {result.reason}",
+                    validation_id=result.validation_id,
+                    reason=result.reason,
+                    checks=[check.model_dump() for check in result.checks] if result.checks else [],
+                    evidence_uri=result.evidence_uri,
+                )
+
+            return result.validation_id
+
+        except ProofGateError as e:
+            if self.config.fail_open:
+                logger.warning(f"ProofGate API error (fail_open=True): {e}")
+                return "fail_open_bypass"
+            raise ProofGateValidationError(
+                message=f"ProofGate API error: {e}",
+                reason=str(e),
+            ) from e
+
+    @create_action(
+        name="validate_transaction",
+        description="""
+        Validate a blockchain transaction through ProofGate before execution.
+
+        This tool checks if a transaction is safe to execute by validating it
+        against ProofGate's security guardrails. Use this before any transaction
+        that sends funds or interacts with contracts.
+
+        Inputs:
+        - to: The destination address of the transaction
+        - data: The transaction calldata in hex format (default: "0x")
+        - value: The value to send in wei (default: "0")
+        - guardrail_id: Optional override for the guardrail ID
+
+        Returns the validation result with proof ID if safe, or blocks with reason.
+        """,
+        schema=ValidateTransactionSchema,
+    )
+    def validate_transaction_action(
+        self, wallet_provider: EvmWalletProvider, args: dict[str, Any]
+    ) -> str:
+        """Validate a transaction through ProofGate.
+
+        Args:
+            wallet_provider: The wallet provider instance.
+            args: Input arguments for the action.
+
+        Returns:
+            A message with validation result.
+        """
+        try:
+            validated_args = ValidateTransactionSchema(**args)
+            from_address = wallet_provider.get_address()
+            network = wallet_provider.get_network()
+            chain_id = int(network.chain_id) if network.chain_id else self.config.chain_id
+
+            proof_id = self.validate_transaction(
+                from_address=from_address,
+                to=validated_args.to,
+                data=validated_args.data,
+                value=validated_args.value,
+                chain_id=chain_id,
+                guardrail_id=validated_args.guardrail_id,
+            )
+
+            return (
+                f"✅ Transaction validated by ProofGate\n"
+                f"Proof ID: {proof_id}\n"
+                f"From: {from_address}\n"
+                f"To: {validated_args.to}\n"
+                f"Value: {validated_args.value} wei\n"
+                f"The transaction is safe to execute."
+            )
+
+        except ProofGateValidationError as e:
+            return (
+                f"🚫 Transaction BLOCKED by ProofGate\n"
+                f"Reason: {e.reason}\n"
+                f"Validation ID: {e.validation_id}\n"
+                f"Evidence: {e.evidence_uri or 'N/A'}\n"
+                f"DO NOT execute this transaction."
+            )
+
+        except Exception as e:
+            return f"Error validating transaction: {e}"
+
+    @create_action(
+        name="check_agent_trust",
+        description="""
+        Check an agent wallet's trust score on ProofGate.
+
+        This tool retrieves the trust score and verification status of an
+        agent wallet address. Higher trust scores may have higher spending limits.
+
+        Inputs:
+        - wallet_address: The wallet address to check
+
+        Returns the agent's trust score, tier, and verification status.
+        """,
+        schema=CheckAgentSchema,
+    )
+    def check_agent_trust(
+        self, wallet_provider: EvmWalletProvider, args: dict[str, Any]
+    ) -> str:
+        """Check an agent's trust score.
+
+        Args:
+            wallet_provider: The wallet provider instance.
+            args: Input arguments for the action.
+
+        Returns:
+            A message with the agent's trust information.
+        """
+        try:
+            validated_args = CheckAgentSchema(**args)
+            agent = self._client.check_agent(validated_args.wallet_address)
+
+            return (
+                f"Agent Trust Score for {validated_args.wallet_address}:\n"
+                f"- Trust Score: {agent.trust_score}\n"
+                f"- Tier: {agent.tier}\n"
+                f"- Verification Status: {agent.verification_status}"
+            )
+
+        except ProofGateError as e:
+            return f"Error checking agent trust: {e}"
+
+        except Exception as e:
+            return f"Error: {e}"
+
+    def supports_network(self, network: Network) -> bool:
+        """Check if the network is supported.
+
+        ProofGate supports EVM networks.
+
+        Args:
+            network: The network to check.
+
+        Returns:
+            True if the network is EVM-based.
+        """
+        return network.protocol_family == "evm"
+
+
+def proofgate_action_provider(
+    api_key: str,
+    guardrail_id: Optional[str] = None,
+    chain_id: Optional[int] = None,
+    fail_open: bool = False,
+    **kwargs: Any,
+) -> ProofGateActionProvider:
+    """Create a new ProofGateActionProvider instance.
+
+    This is a convenience factory function for creating the provider.
+
+    Args:
+        api_key: ProofGate API key.
+        guardrail_id: Default guardrail ID.
+        chain_id: Default chain ID.
+        fail_open: Whether to allow transactions on API failure.
+        **kwargs: Additional config options.
+
+    Returns:
+        A configured ProofGateActionProvider.
+
+    Example:
+        ```python
+        provider = proofgate_action_provider(
+            api_key="pg_your_api_key",
+            guardrail_id="your_guardrail_id",
+            chain_id=8453,  # Base
+        )
+        ```
+    """
+    config = ProofGateConfig(
+        api_key=api_key,
+        guardrail_id=guardrail_id,
+        chain_id=chain_id,
+        fail_open=fail_open,
+        **kwargs,
+    )
+    return ProofGateActionProvider(config)

proofgate_agentkit/config.py

@@ -0,0 +1,33 @@
+"""Configuration for ProofGate Action Provider."""
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ProofGateConfig(BaseModel):
+    """Configuration for ProofGate validation.
+
+    Attributes:
+        api_key: ProofGate API key (required). Get from proofgate.xyz/dashboard.
+        guardrail_id: Default guardrail ID to use for validation.
+        chain_id: Default chain ID (e.g., 1 for Ethereum, 8453 for Base).
+        base_url: Custom API base URL. Defaults to ProofGate's production API.
+        timeout: Request timeout in seconds.
+        fail_open: If True, allow transactions when ProofGate API is unreachable.
+                   Default False (fail closed for security).
+        log_validations: If True, log validation results. Default True.
+    """
+
+    api_key: str = Field(..., description="ProofGate API key")
+    guardrail_id: Optional[str] = Field(None, description="Default guardrail ID")
+    chain_id: Optional[int] = Field(None, description="Default chain ID")
+    base_url: Optional[str] = Field(None, description="Custom API base URL")
+    timeout: float = Field(30.0, description="Request timeout in seconds")
+    fail_open: bool = Field(False, description="Allow tx on API failure")
+    log_validations: bool = Field(True, description="Log validation results")
+
+    class Config:
+        """Pydantic config."""
+
+        extra = "forbid"

proofgate_agentkit/exceptions.py

@@ -0,0 +1,48 @@
+"""Exceptions for ProofGate Action Provider."""
+
+from typing import Any, Optional
+
+
+class ProofGateValidationError(Exception):
+    """Raised when ProofGate blocks a transaction.
+
+    Attributes:
+        validation_id: The ProofGate validation ID.
+        reason: The reason the transaction was blocked.
+        checks: List of validation checks that were performed.
+        evidence_uri: URI to the evidence for this validation.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        validation_id: Optional[str] = None,
+        reason: Optional[str] = None,
+        checks: Optional[list[dict[str, Any]]] = None,
+        evidence_uri: Optional[str] = None,
+    ) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: Human-readable error message.
+            validation_id: The ProofGate validation ID.
+            reason: The reason the transaction was blocked.
+            checks: List of validation checks performed.
+            evidence_uri: URI to validation evidence.
+        """
+        super().__init__(message)
+        self.validation_id = validation_id
+        self.reason = reason
+        self.checks = checks or []
+        self.evidence_uri = evidence_uri
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        parts = [str(self.args[0])]
+        if self.reason:
+            parts.append(f"Reason: {self.reason}")
+        if self.validation_id:
+            parts.append(f"Validation ID: {self.validation_id}")
+        if self.evidence_uri:
+            parts.append(f"Evidence: {self.evidence_uri}")
+        return " | ".join(parts)

proofgate_agentkit/wrapper.py

@@ -0,0 +1,290 @@
+"""Transaction wrapper that adds ProofGate validation to any action provider.
+
+This module provides utilities to wrap existing action providers with
+ProofGate validation, intercepting transactions before execution.
+"""
+
+import functools
+import logging
+from typing import Any, Callable, Optional, TypeVar
+
+from coinbase_agentkit.action_providers import Action, ActionProvider
+from coinbase_agentkit.wallet_providers import EvmWalletProvider
+
+from .action_provider import ProofGateActionProvider
+from .config import ProofGateConfig
+from .exceptions import ProofGateValidationError
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class ProofGateWrapper:
+    """Wraps wallet provider methods to add ProofGate validation.
+
+    This class intercepts transaction methods (send_transaction, native_transfer)
+    and validates them through ProofGate before execution.
+
+    Example:
+        ```python
+        from proofgate_agentkit import ProofGateWrapper, ProofGateConfig
+
+        config = ProofGateConfig(api_key="pg_xxx", guardrail_id="xxx")
+        wrapper = ProofGateWrapper(config)
+
+        # Wrap the wallet provider
+        wrapped_wallet = wrapper.wrap(wallet_provider)
+
+        # Now all transactions will be validated
+        wrapped_wallet.send_transaction({...})  # Validated first!
+        ```
+    """
+
+    def __init__(self, config: ProofGateConfig) -> None:
+        """Initialize the wrapper.
+
+        Args:
+            config: ProofGate configuration.
+        """
+        self.config = config
+        self._provider = ProofGateActionProvider(config)
+
+    def wrap(self, wallet_provider: EvmWalletProvider) -> EvmWalletProvider:
+        """Wrap a wallet provider with ProofGate validation.
+
+        This patches the wallet provider's send_transaction method to
+        validate transactions before execution.
+
+        Args:
+            wallet_provider: The wallet provider to wrap.
+
+        Returns:
+            The same wallet provider with patched methods.
+        """
+        original_send = wallet_provider.send_transaction
+
+        @functools.wraps(original_send)
+        def validated_send(tx: dict[str, Any]) -> str:
+            """Send transaction after ProofGate validation."""
+            from_address = wallet_provider.get_address()
+            network = wallet_provider.get_network()
+            chain_id = int(network.chain_id) if network.chain_id else self.config.chain_id
+
+            to = tx.get("to", "")
+            data = tx.get("data", "0x")
+            value = str(tx.get("value", 0))
+
+            # Validate through ProofGate
+            proof_id = self._provider.validate_transaction(
+                from_address=from_address,
+                to=to,
+                data=data,
+                value=value,
+                chain_id=chain_id,
+            )
+
+            logger.info(f"ProofGate approved transaction | Proof ID: {proof_id}")
+
+            # Execute the original transaction
+            return original_send(tx)
+
+        # Patch the method
+        wallet_provider.send_transaction = validated_send  # type: ignore
+
+        return wallet_provider
+
+
+def wrap_with_proofgate(
+    action_provider: ActionProvider[EvmWalletProvider],
+    config: ProofGateConfig,
+) -> ActionProvider[EvmWalletProvider]:
+    """Wrap an action provider's transaction actions with ProofGate validation.
+
+    This creates a wrapper that intercepts actions that result in transactions
+    and validates them through ProofGate first.
+
+    Args:
+        action_provider: The action provider to wrap.
+        config: ProofGate configuration.
+
+    Returns:
+        A wrapped action provider.
+
+    Example:
+        ```python
+        from coinbase_agentkit.action_providers import erc20_action_provider
+        from proofgate_agentkit import wrap_with_proofgate, ProofGateConfig
+
+        config = ProofGateConfig(api_key="pg_xxx")
+        erc20 = erc20_action_provider()
+        safe_erc20 = wrap_with_proofgate(erc20, config)
+        ```
+    """
+    pg_provider = ProofGateActionProvider(config)
+
+    class WrappedActionProvider(ActionProvider[EvmWalletProvider]):
+        """Wrapper that validates transactions through ProofGate."""
+
+        def __init__(self) -> None:
+            super().__init__(
+                f"proofgate_wrapped_{action_provider.name}",
+                [action_provider],
+            )
+            self._inner = action_provider
+            self._pg = pg_provider
+
+        def get_actions(self, wallet_provider: EvmWalletProvider) -> list[Action]:
+            """Get wrapped actions that validate through ProofGate."""
+            original_actions = self._inner.get_actions(wallet_provider)
+            wrapped_actions = []
+
+            # Actions that modify state (need validation)
+            tx_action_names = {
+                "transfer",
+                "approve",
+                "native_transfer",
+                "swap",
+                "supply",
+                "withdraw",
+                "borrow",
+                "repay",
+                "wrap",
+                "unwrap",
+                "mint",
+                "burn",
+            }
+
+            for action in original_actions:
+                # Check if this is a transaction action
+                action_name_lower = action.name.lower()
+                needs_validation = any(
+                    tx_name in action_name_lower for tx_name in tx_action_names
+                )
+
+                if needs_validation:
+                    wrapped_actions.append(
+                        self._wrap_action(action, wallet_provider)
+                    )
+                else:
+                    wrapped_actions.append(action)
+
+            return wrapped_actions
+
+        def _wrap_action(
+            self, action: Action, wallet_provider: EvmWalletProvider
+        ) -> Action:
+            """Wrap an action with ProofGate validation."""
+            original_invoke = action.invoke
+
+            def wrapped_invoke(args: dict[str, Any]) -> str:
+                """Invoke with ProofGate validation."""
+                # Extract transaction details from args
+                to = args.get("to") or args.get("contract_address") or args.get("destination_address", "")
+                value = str(args.get("value", 0))
+
+                if to:
+                    try:
+                        from_address = wallet_provider.get_address()
+                        network = wallet_provider.get_network()
+                        chain_id = int(network.chain_id) if network.chain_id else config.chain_id
+
+                        proof_id = self._pg.validate_transaction(
+                            from_address=from_address,
+                            to=to,
+                            data="0x",  # Simplified - could extract real data
+                            value=value,
+                            chain_id=chain_id,
+                        )
+
+                        logger.info(
+                            f"ProofGate approved {action.name} | "
+                            f"Proof ID: {proof_id}"
+                        )
+
+                    except ProofGateValidationError as e:
+                        return (
+                            f"🚫 Action BLOCKED by ProofGate\n"
+                            f"Action: {action.name}\n"
+                            f"Reason: {e.reason}\n"
+                            f"Validation ID: {e.validation_id}\n"
+                            f"This action was not executed."
+                        )
+
+                return original_invoke(args)
+
+            return Action(
+                name=action.name,
+                description=f"[ProofGate Protected] {action.description}",
+                args_schema=action.args_schema,
+                invoke=wrapped_invoke,
+            )
+
+        def supports_network(self, network: Any) -> bool:
+            """Check network support."""
+            return self._inner.supports_network(network)
+
+    return WrappedActionProvider()
+
+
+def create_validated_action(
+    config: ProofGateConfig,
+    extract_tx_params: Optional[Callable[[dict[str, Any]], dict[str, Any]]] = None,
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """Decorator to add ProofGate validation to an action function.
+
+    Args:
+        config: ProofGate configuration.
+        extract_tx_params: Function to extract tx params (to, data, value) from args.
+
+    Returns:
+        A decorator that adds validation.
+
+    Example:
+        ```python
+        @create_validated_action(config)
+        def my_transfer_action(wallet_provider, args):
+            # This will be validated first
+            ...
+        ```
+    """
+    pg_provider = ProofGateActionProvider(config)
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        def wrapper(
+            self: Any,
+            wallet_provider: EvmWalletProvider,
+            args: dict[str, Any],
+        ) -> T:
+            # Extract transaction parameters
+            if extract_tx_params:
+                tx_params = extract_tx_params(args)
+            else:
+                tx_params = {
+                    "to": args.get("to") or args.get("contract_address", ""),
+                    "data": args.get("data", "0x"),
+                    "value": str(args.get("value", 0)),
+                }
+
+            if tx_params.get("to"):
+                from_address = wallet_provider.get_address()
+                network = wallet_provider.get_network()
+                chain_id = int(network.chain_id) if network.chain_id else config.chain_id
+
+                # This will raise ProofGateValidationError if blocked
+                proof_id = pg_provider.validate_transaction(
+                    from_address=from_address,
+                    to=tx_params["to"],
+                    data=tx_params.get("data", "0x"),
+                    value=tx_params.get("value", "0"),
+                    chain_id=chain_id,
+                )
+
+                logger.info(f"ProofGate validated | Proof ID: {proof_id}")
+
+            return func(self, wallet_provider, args)
+
+        return wrapper
+
+    return decorator

proofgate_agentkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,343 @@
+Metadata-Version: 2.4
+Name: proofgate-agentkit
+Version: 0.1.0
+Summary: ProofGate Action Provider for Coinbase AgentKit - Blockchain guardrails for AI agents
+License: MIT
+License-File: LICENSE
+Keywords: proofgate,agentkit,coinbase,blockchain,security,ai-agent,guardrails
+Author: bytes0xcr6
+Author-email: 102038261+bytes0xcr6@users.noreply.github.com
+Requires-Python: >=3.10,<4.0
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: coinbase-agentkit (>=0.1.0,<0.2.0)
+Requires-Dist: proofgate (>=0.1.0,<0.2.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Project-URL: Documentation, https://docs.proofgate.xyz
+Project-URL: Homepage, https://github.com/proofgate/proofgate-agentkit
+Project-URL: Repository, https://github.com/proofgate/proofgate-agentkit
+Description-Content-Type: text/markdown
+
+# proofgate-agentkit
+
+> ProofGate Action Provider for Coinbase AgentKit - Blockchain guardrails for AI agents
+
+[![PyPI version](https://badge.fury.io/py/proofgate-agentkit.svg)](https://pypi.org/project/proofgate-agentkit/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-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 this?
+
+`proofgate-agentkit` integrates [ProofGate](https://proofgate.xyz) with [Coinbase AgentKit](https://github.com/coinbase/agentkit), providing security guardrails for AI agent blockchain transactions.
+
+**ProofGate validates transactions before your AI agent executes them**, preventing:
+
+- 🚫 **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-agentkit
+```
+
+Or with Poetry:
+
+```bash
+poetry add proofgate-agentkit
+```
+
+## Quick Start
+
+### 1. As an Action Provider
+
+Add ProofGate as an action provider to validate transactions explicitly:
+
+```python
+from coinbase_agentkit import AgentKit, AgentKitConfig
+from proofgate_agentkit import proofgate_action_provider
+
+# Create the ProofGate action provider
+proofgate = proofgate_action_provider(
+    api_key="pg_your_api_key",      # Get from proofgate.xyz/dashboard
+    guardrail_id="your_guardrail",   # Create at proofgate.xyz/guardrails
+    chain_id=8453,                   # Base mainnet
+)
+
+# Add to your AgentKit configuration
+agent = AgentKit(
+    config=AgentKitConfig(
+        # ... your config
+    ),
+    action_providers=[
+        proofgate,
+        # ... other providers
+    ],
+)
+```
+
+Now your agent has access to these actions:
+- `validate_transaction` - Validate a transaction before execution
+- `check_agent_trust` - Check a wallet's trust score
+
+### 2. Wrap Existing Providers
+
+Automatically validate all transactions from any action provider:
+
+```python
+from coinbase_agentkit.action_providers import erc20_action_provider, wallet_action_provider
+from proofgate_agentkit import wrap_with_proofgate, ProofGateConfig
+
+config = ProofGateConfig(
+    api_key="pg_your_api_key",
+    guardrail_id="your_guardrail",
+)
+
+# Wrap providers - all their transaction actions will be validated
+safe_erc20 = wrap_with_proofgate(erc20_action_provider(), config)
+safe_wallet = wrap_with_proofgate(wallet_action_provider(), config)
+
+agent = AgentKit(
+    config=AgentKitConfig(...),
+    action_providers=[safe_erc20, safe_wallet],
+)
+```
+
+### 3. Wrap the Wallet Provider
+
+Validate ALL transactions at the wallet level:
+
+```python
+from coinbase_agentkit.wallet_providers import CdpWalletProvider
+from proofgate_agentkit import ProofGateWrapper, ProofGateConfig
+
+# Create wallet provider
+wallet = CdpWalletProvider(...)
+
+# Wrap with ProofGate
+config = ProofGateConfig(
+    api_key="pg_your_api_key",
+    guardrail_id="your_guardrail",
+)
+wrapper = ProofGateWrapper(config)
+safe_wallet = wrapper.wrap(wallet)
+
+# Now every send_transaction() call is validated first
+agent = AgentKit(
+    config=AgentKitConfig(...),
+    wallet_provider=safe_wallet,
+)
+```
+
+## Configuration
+
+```python
+from proofgate_agentkit import ProofGateConfig
+
+config = ProofGateConfig(
+    # Required
+    api_key="pg_xxx",              # Your ProofGate API key
+
+    # Optional
+    guardrail_id="xxx",            # Default guardrail to use
+    chain_id=8453,                 # Default chain (8453 = Base)
+    base_url="https://...",        # Custom API URL
+    timeout=30.0,                  # Request timeout (seconds)
+    fail_open=False,               # Allow tx on API failure (default: False)
+    log_validations=True,          # Log validation results (default: True)
+)
+```
+
+### Fail Open vs Fail Closed
+
+By default, `fail_open=False` means:
+- If ProofGate API is unreachable, transactions are **blocked**
+- This is the secure default
+
+Set `fail_open=True` for:
+- Allow transactions when ProofGate is unavailable
+- Useful for testing or when availability > security
+
+## Usage Examples
+
+### Explicit Validation
+
+```python
+from proofgate_agentkit import ProofGateActionProvider, ProofGateConfig, ProofGateValidationError
+
+config = ProofGateConfig(api_key="pg_xxx", guardrail_id="xxx")
+provider = ProofGateActionProvider(config)
+
+try:
+    proof_id = provider.validate_transaction(
+        from_address="0xYourAgent...",
+        to="0xContract...",
+        data="0xa9059cbb...",
+        value="0",
+    )
+    print(f"✅ Safe! Proof ID: {proof_id}")
+    # Execute transaction...
+
+except ProofGateValidationError as e:
+    print(f"🚫 Blocked: {e.reason}")
+    print(f"Evidence: {e.evidence_uri}")
+```
+
+### With LangChain
+
+```python
+from langchain_openai import ChatOpenAI
+from coinbase_agentkit import AgentKit
+from coinbase_agentkit_langchain import get_langchain_tools
+from proofgate_agentkit import proofgate_action_provider
+
+# Setup AgentKit with ProofGate
+agent_kit = AgentKit(
+    config=config,
+    action_providers=[
+        proofgate_action_provider(
+            api_key="pg_xxx",
+            guardrail_id="xxx",
+        ),
+        # ... other providers
+    ],
+)
+
+# Get tools for LangChain
+tools = get_langchain_tools(agent_kit)
+
+# Create agent
+llm = ChatOpenAI(model="gpt-4")
+agent = create_react_agent(llm, tools)
+```
+
+### Programmatic Validation in Custom Actions
+
+```python
+from coinbase_agentkit.action_providers import ActionProvider, create_action
+from proofgate_agentkit import ProofGateActionProvider, ProofGateConfig
+
+class MyCustomProvider(ActionProvider):
+    def __init__(self):
+        super().__init__("my_custom", [])
+        
+        # Initialize ProofGate for validation
+        config = ProofGateConfig(api_key="pg_xxx")
+        self._proofgate = ProofGateActionProvider(config)
+
+    @create_action(name="dangerous_action", description="...", schema=MySchema)
+    def dangerous_action(self, wallet_provider, args):
+        # Validate first!
+        self._proofgate.validate_transaction(
+            from_address=wallet_provider.get_address(),
+            to=args["to"],
+            data=args["data"],
+            value=args["value"],
+        )
+        
+        # If we get here, it's safe
+        return wallet_provider.send_transaction({...})
+```
+
+## Guardrails
+
+Guardrails define what your agent can do. Create them at [proofgate.xyz/guardrails](https://www.proofgate.xyz/guardrails).
+
+Example 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
+- ✅ **Blocked methods**: No `setApprovalForAll`
+
+## Error Handling
+
+```python
+from proofgate_agentkit import ProofGateValidationError
+
+try:
+    provider.validate_transaction(...)
+except ProofGateValidationError as e:
+    print(f"Blocked: {e.reason}")
+    print(f"Validation ID: {e.validation_id}")
+    print(f"Evidence URI: {e.evidence_uri}")
+    
+    # Access individual check results
+    for check in e.checks:
+        print(f"  - {check['name']}: {check['result']}")
+```
+
+## API Reference
+
+### ProofGateActionProvider
+
+The main action provider class.
+
+**Methods:**
+- `validate_transaction(from_address, to, data, value, chain_id, guardrail_id)` → `str`
+  - Returns proof_id if safe, raises `ProofGateValidationError` if blocked
+
+**Actions (for LLM agents):**
+- `validate_transaction` - Validate a transaction
+- `check_agent_trust` - Check wallet trust score
+
+### ProofGateWrapper
+
+Wraps wallet providers for automatic validation.
+
+**Methods:**
+- `wrap(wallet_provider)` → `EvmWalletProvider`
+  - Returns the same provider with patched `send_transaction`
+
+### wrap_with_proofgate
+
+Factory function to wrap action providers.
+
+```python
+wrapped = wrap_with_proofgate(provider, config)
+```
+
+## Development
+
+```bash
+# Clone
+git clone https://github.com/proofgate/proofgate-agentkit
+cd proofgate-agentkit/python
+
+# Install dependencies
+poetry install
+
+# Run tests
+poetry run pytest
+
+# Format
+poetry run black .
+poetry run ruff check --fix .
+
+# Type check
+poetry run mypy proofgate_agentkit
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- 🌐 [ProofGate Website](https://proofgate.xyz)
+- 📚 [Documentation](https://docs.proofgate.xyz)
+- 🔧 [Coinbase AgentKit](https://github.com/coinbase/agentkit)
+- 🐍 [proofgate Python SDK](https://pypi.org/project/proofgate/)
+

proofgate_agentkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+proofgate_agentkit/__init__.py,sha256=Lsqm3LN4D2OP6reOqw1QXu3JUNVFoW5VpLSn9RDQ7iU,660
+proofgate_agentkit/action_provider.py,sha256=X_H5Cq9JK9fXUOa2jt4ssVXwIP61B4zGccqqb5YgOrs,10253
+proofgate_agentkit/config.py,sha256=o1OZGSscpt4CiC7yhRgLuToNNIWXB6IbpzEkOZ27VvY,1387
+proofgate_agentkit/exceptions.py,sha256=hHu9nwEdRUqL0mDoj7UUPDeKpDw-_Mkh2t4AI8_UwWo,1617
+proofgate_agentkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proofgate_agentkit/wrapper.py,sha256=x7jvvdbpqeuKcX0ZXB6jkuQiLhG8uzWENKWUMgiM2IQ,10066
+proofgate_agentkit-0.1.0.dist-info/METADATA,sha256=zS1JXuwIqWoYNWOKSBvo25_tO7QSVvGHtC-cmyYZUTM,9826
+proofgate_agentkit-0.1.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+proofgate_agentkit-0.1.0.dist-info/licenses/LICENSE,sha256=P65zjuntxfANEktkG--DbihXXh8IiwF__0Zehegy_2U,1066
+proofgate_agentkit-0.1.0.dist-info/RECORD,,

proofgate_agentkit-0.1.0.dist-info/WHEEL

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

proofgate_agentkit-0.1.0.dist-info/licenses/LICENSE

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