grid402 2.2.0__py3-none-any.whl

grid402/__init__.py

@@ -0,0 +1,50 @@
+"""
+Grid402 Python SDK - Biblioteca oficial para a Internet Agente e Micropagamentos HTTP 402.
+
+Suporte para Python 3.9+, Coinbase Developer Platform (CDP) AgentKit,
+LangChain, CrewAI e modo Sandbox gratuito.
+"""
+
+from grid402.agentkit import Grid402ActionProvider
+from grid402.client import DEFAULT_ENDPOINT, Grid402Client
+from grid402.exceptions import Grid402Error, Grid402PaymentRequiredError
+from grid402.models import (
+    AsnInput,
+    CepInput,
+    CnpjInput,
+    CryptoInput,
+    DnsInput,
+    EconomicIndicators,
+    HolidayItem,
+    HolidaysInput,
+    HolidaysResponse,
+    IndicatorsResponse,
+    SettlementInfo,
+    SslInput,
+)
+
+__version__ = "2.2.0"
+__author__ = "Grid402 Team"
+__license__ = "MIT"
+
+__all__ = [
+    "Grid402Client",
+    "Grid402ActionProvider",
+    "Grid402Error",
+    "Grid402PaymentRequiredError",
+    "CnpjInput",
+    "CepInput",
+    "DnsInput",
+    "SslInput",
+    "AsnInput",
+    "CryptoInput",
+    "HolidaysInput",
+    "EconomicIndicators",
+    "IndicatorsResponse",
+    "HolidayItem",
+    "HolidaysResponse",
+    "SettlementInfo",
+    "DEFAULT_ENDPOINT",
+    "__version__",
+]
+

grid402/agentkit.py

@@ -0,0 +1,186 @@
+"""
+Grid402 Action Provider para Coinbase AgentKit, LangChain e CrewAI.
+
+Permite que agentes autonomos com carteiras CDP (Coinbase Developer Platform)
+na rede Base consultem dados cadastrais e utilitarios de rede com auto-liquidacao x402.
+"""
+
+from typing import Any, Dict, Optional
+import json
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from grid402.client import DEFAULT_ENDPOINT
+from grid402.models import AsnInput, CepInput, CnpjInput, CryptoInput, DnsInput, SslInput
+
+
+GRID402_ORACLE_WALLET = "0xa31c31069c43ac1c0075a93c325b0dcd7744356c"
+BASE_USDC_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+
+
+class Grid402ActionProvider:
+    """
+    Provedor de acoes do Grid402 compativel com Coinbase AgentKit, LangChain e CrewAI.
+    
+    Gerencia o ciclo de vida completo de micropagamentos x402 de forma autonoma,
+    detectando desafios HTTP 402, efetuando a transferencia de USDC on-chain
+    na Base e reenviando a requisicao com o comprovante criptografico.
+    """
+
+    def __init__(self, base_url: str = DEFAULT_ENDPOINT, sandbox: bool = False):
+        """
+        Inicializa o provedor de acoes Grid402.
+        
+        Args:
+            base_url: URL base da API do Grid402.
+            sandbox: Se True, opera em modo Sandbox gratuito sem consumir USDC real.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.sandbox = sandbox
+
+    def _get_ssl_context(self) -> ssl.SSLContext:
+        ctx = ssl.create_default_context()
+        if "hostingersite.com" in self.base_url:
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+    def _execute_with_settlement(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        wallet_provider: Any = None,
+    ) -> Dict[str, Any]:
+        """
+        Executa a requisicao HTTP com auto-liquidacao de desafio x402.
+        
+        Se o endpoint retornar HTTP 402 e um wallet_provider estiver disponivel,
+        executa a transferencia de micropagamento em USDC na Base e repete a chamada.
+        """
+        filtered_params = {k: v for k, v in (params or {}).items() if v is not None}
+        query_string = urllib.parse.urlencode(filtered_params)
+
+        url = f"{self.base_url}{path}"
+        if query_string:
+            url += f"?{query_string}"
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "Grid402-CoinbaseAgentKit-Python/1.0",
+        }
+
+        if self.sandbox:
+            headers["X-Payment"] = "demo"
+
+        req = urllib.request.Request(url, headers=headers)
+        ctx = self._get_ssl_context()
+
+        # 1. Primeira tentativa de requisicao
+        try:
+            with urllib.request.urlopen(req, context=ctx, timeout=10) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raw_body = exc.read().decode("utf-8")
+            try:
+                challenge = json.loads(raw_body)
+            except Exception:
+                challenge = {"error": raw_body, "status_code": exc.code}
+
+            # 2. Se retornou HTTP 402 Payment Required
+            if exc.code == 402:
+                # Se temos wallet_provider e nao estamos no sandbox, auto-liquida on-chain
+                if wallet_provider is not None and not self.sandbox:
+                    price_usdc = challenge.get("price_usdc", "0.0005")
+                    recipient = challenge.get("recipient_wallet", GRID402_ORACLE_WALLET)
+
+                    try:
+                        # Executa transferencia de USDC na Base usando a carteira CDP
+                        transfer_result = wallet_provider.transfer(
+                            to=recipient,
+                            amount=price_usdc,
+                            asset_id="usdc",
+                        )
+                        tx_hash = getattr(transfer_result, "transaction_hash", str(transfer_result))
+
+                        # Reenvia com cabecalho X-Payment
+                        headers["X-Payment"] = tx_hash
+                        retry_req = urllib.request.Request(url, headers=headers)
+                        with urllib.request.urlopen(retry_req, context=ctx, timeout=10) as retry_res:
+                            data = json.loads(retry_res.read().decode("utf-8"))
+                            data["_x402_settlement"] = {
+                                "settled": True,
+                                "tx_hash": tx_hash,
+                                "price_usdc": price_usdc,
+                                "network": "Base",
+                                "token": "USDC",
+                            }
+                            return data
+                    except Exception as pay_err:
+                        challenge["payment_error"] = str(pay_err)
+                        challenge["payment_required"] = True
+                        return challenge
+
+                challenge["payment_required"] = True
+                return challenge
+            raise
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Resumo operacional consolidado e disponibilidade do hub Grid402 (gratuito)."""
+        return self._execute_with_settlement("/status")
+
+    def query_forex(self, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Consulta cotacoes fiduciarias de USD, EUR e GBP para BRL em tempo real."""
+        return self._execute_with_settlement("/api/v1/forex", {}, wallet_provider)
+
+    def query_crypto(
+        self, symbol: Optional[str] = None, wallet_provider: Any = None
+    ) -> Dict[str, Any]:
+        """Consulta precos de mercado spot de criptoativos em USD e BRL."""
+        params = {"symbol": symbol} if symbol else {}
+        return self._execute_with_settlement("/api/v1/crypto", params, wallet_provider)
+
+    def query_dns(self, domain: str, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Executa resolucao autoritativa de registros DNS para qualquer dominio."""
+        return self._execute_with_settlement("/api/v1/dns", {"domain": domain}, wallet_provider)
+
+    def query_ssl(self, host: str, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Inspeciona e audita certificado TLS e SSL na porta 443 de um host."""
+        return self._execute_with_settlement("/api/v1/ssl", {"host": host}, wallet_provider)
+
+    def query_asn(self, ip: Optional[str] = None, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Consulta inteligencia de rede BGP, numero de ASN e organizacao titular."""
+        params = {"ip": ip} if ip else {}
+        return self._execute_with_settlement("/api/v1/asn", params, wallet_provider)
+
+    def query_cep(self, code: str, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Consulta endereco postal brasileiro e codigo oficial IBGE por CEP."""
+        return self._execute_with_settlement("/api/v1/cep", {"code": code}, wallet_provider)
+
+    def query_cnpj(self, cnpj: str, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Consulta dados cadastrais de Pessoa Juridica na Receita Federal."""
+        return self._execute_with_settlement("/api/v1/cnpj", {"cnpj": cnpj}, wallet_provider)
+
+    def query_indicators(self, wallet_provider: Any = None) -> Dict[str, Any]:
+        """Consulta taxas oficiais Selic meta e diaria, CDI anual e diario, IPCA 12m e mensal."""
+        return self._execute_with_settlement("/api/v1/indicators", {}, wallet_provider)
+
+    def query_holidays(
+        self, year: Optional[int] = None, wallet_provider: Any = None
+    ) -> Dict[str, Any]:
+        """Consulta o calendario oficial de feriados nacionais e dias sem expediente bancario."""
+        params = {"year": year} if year is not None else {}
+        return self._execute_with_settlement("/api/v1/holidays", params, wallet_provider)
+
+    # Aliases no padrao snake_case das ferramentas MCP
+    get_cnpj = query_cnpj
+    get_cep = query_cep
+    get_forex = query_forex
+    get_crypto = query_crypto
+    get_dns = query_dns
+    get_ssl = query_ssl
+    get_asn = query_asn
+    get_indicators = query_indicators
+    get_holidays = query_holidays
+

grid402/client.py

@@ -0,0 +1,156 @@
+"""
+Cliente HTTP oficial para a API de Micropagamentos Grid402.
+"""
+
+from typing import Any, Dict, Optional
+import json
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from grid402.exceptions import Grid402Error, Grid402PaymentRequiredError
+
+
+DEFAULT_ENDPOINT = "https://grid402.com.br"
+
+
+class Grid402Client:
+    """
+    Cliente Python para consumo das ferramentas públicas do Grid402.
+    
+    Suporta modo de producao na Base Mainnet, modo Sandbox gratuito para testes
+    e tratamento estruturado de desafios HTTP 402.
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_ENDPOINT,
+        sandbox: bool = False,
+        payment_tx_hash: Optional[str] = None,
+        timeout: int = 10,
+        raise_for_payment: bool = False,
+    ):
+        """
+        Inicializa uma nova instancia do Grid402Client.
+        
+        Args:
+            base_url: Endereco base da API do Grid402.
+            sandbox: Se True, ativa o modo Sandbox gratuito para homologacao sem custo.
+            payment_tx_hash: Hash de transacao USDC opcional padrao para as requisicoes.
+            timeout: Tempo limite em segundos para cada requisicao HTTP.
+            raise_for_payment: Se True, lanca Grid402PaymentRequiredError ao receber HTTP 402.
+                              Se False, retorna o dicionario com o desafio e dados parciais.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.sandbox = sandbox
+        self.payment_tx_hash = payment_tx_hash
+        self.timeout = timeout
+        self.raise_for_payment = raise_for_payment
+
+    def _get_ssl_context(self) -> ssl.SSLContext:
+        ctx = ssl.create_default_context()
+        if "hostingersite.com" in self.base_url:
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+    def _request(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        payment_tx_hash: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Executa a requisicao HTTP para a API Grid402."""
+        filtered_params = {k: v for k, v in (params or {}).items() if v is not None}
+        query_string = urllib.parse.urlencode(filtered_params)
+
+        url = f"{self.base_url}{path}"
+        if query_string:
+            url += f"?{query_string}"
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "Grid402-Python-SDK/2.2",
+        }
+
+        active_tx_hash = payment_tx_hash or self.payment_tx_hash
+        if active_tx_hash:
+            headers["X-Payment"] = active_tx_hash
+        elif self.sandbox:
+            headers["X-Payment"] = "demo"
+
+        req = urllib.request.Request(url, headers=headers)
+        ctx = self._get_ssl_context()
+
+        try:
+            with urllib.request.urlopen(req, context=ctx, timeout=self.timeout) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raw_body = exc.read().decode("utf-8")
+            try:
+                error_data = json.loads(raw_body)
+            except Exception:
+                error_data = {"error": raw_body, "status_code": exc.code}
+
+            if exc.code == 402:
+                if self.raise_for_payment:
+                    raise Grid402PaymentRequiredError(error_data) from exc
+                error_data["payment_required"] = True
+                return error_data
+
+            raise Grid402Error(
+                f"Erro na API Grid402 (HTTP {exc.code}): {error_data.get('error') or raw_body}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise Grid402Error(f"Falha de conexao com {self.base_url}: {exc.reason}") from exc
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Consulta o resumo e status operacional consolidado do Grid402 (gratuito)."""
+        return self._request("/status")
+
+    def get_forex(self, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Consulta cotacoes fiduciarias oficiais em tempo real de USD, EUR e GBP para BRL."""
+        return self._request("/api/v1/forex", payment_tx_hash=payment_tx_hash)
+
+    def get_crypto(
+        self, symbol: Optional[str] = None, payment_tx_hash: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Consulta precos de mercado spot de criptoativos em tempo real."""
+        params = {"symbol": symbol} if symbol else {}
+        return self._request("/api/v1/crypto", params=params, payment_tx_hash=payment_tx_hash)
+
+    def get_dns(self, domain: str, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Executa resolucao DNS autoritativa de registros A, AAAA, MX, TXT, NS e CNAME."""
+        return self._request("/api/v1/dns", params={"domain": domain}, payment_tx_hash=payment_tx_hash)
+
+    def get_ssl(self, host: str, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Inspeciona e valida o certificado TLS e SSL na porta 443 de um host remoto."""
+        return self._request("/api/v1/ssl", params={"host": host}, payment_tx_hash=payment_tx_hash)
+
+    def get_asn(
+        self, ip: Optional[str] = None, payment_tx_hash: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Consulta inteligencia de rede BGP, identificando numero de ASN e organizacao."""
+        params = {"ip": ip} if ip else {}
+        return self._request("/api/v1/asn", params=params, payment_tx_hash=payment_tx_hash)
+
+    def get_cep(self, code: str, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Consulta a base publica de enderecamento postal brasileiro e codigo IBGE por CEP."""
+        return self._request("/api/v1/cep", params={"code": code}, payment_tx_hash=payment_tx_hash)
+
+    def get_cnpj(self, cnpj: str, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Consulta dados cadastrais publicos de Pessoa Juridica na Receita Federal."""
+        return self._request("/api/v1/cnpj", params={"cnpj": cnpj}, payment_tx_hash=payment_tx_hash)
+
+    def get_indicators(self, payment_tx_hash: Optional[str] = None) -> Dict[str, Any]:
+        """Consulta indicadores economicos oficiais (Selic, CDI e IPCA) do Banco Central e IBGE."""
+        return self._request("/api/v1/indicators", payment_tx_hash=payment_tx_hash)
+
+    def get_holidays(
+        self, year: Optional[int] = None, payment_tx_hash: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Consulta calendario oficial de feriados nacionais e bancarios (ANBIMA e Febraban)."""
+        params = {"year": year} if year is not None else {}
+        return self._request("/api/v1/holidays", params=params, payment_tx_hash=payment_tx_hash)
+

grid402/exceptions.py

@@ -0,0 +1,34 @@
+"""
+Excecoes oficiais do SDK Grid402.
+"""
+
+from typing import Any, Dict, Optional
+
+
+class Grid402Error(Exception):
+    """Excecao base para erros do SDK Grid402."""
+    pass
+
+
+class Grid402PaymentRequiredError(Grid402Error):
+    """
+    Excecao levantada quando um endpoint do Grid402 retorna HTTP 402 Payment Required.
+    
+    Contem todos os metadados do desafio de pagamento x402 e pre-visualizacao parcial.
+    """
+
+    def __init__(self, challenge: Dict[str, Any], message: Optional[str] = None):
+        self.challenge = challenge
+        self.price_usdc: str = challenge.get("price_usdc", "0.0005")
+        self.recipient: str = challenge.get("recipient_wallet", "")
+        self.network: str = challenge.get("network", "Base")
+        self.token: str = challenge.get("token", "USDC")
+        self.preview_data: Optional[Dict[str, Any]] = challenge.get("preview_data")
+        self.payment_details: Optional[Dict[str, Any]] = challenge.get("payment_details")
+
+        default_msg = (
+            f"Pagamento obrigatorio de {self.price_usdc} {self.token} na rede {self.network} "
+            f"para a carteira {self.recipient}."
+        )
+        super().__init__(message or challenge.get("message") or default_msg)
+

grid402/models.py

@@ -0,0 +1,119 @@
+"""
+Modelos tipados Pydantic para entradas e saidas do Grid402.
+"""
+
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+
+
+class CnpjInput(BaseModel):
+    """Parametros para consulta cadastral de Pessoa Juridica na Receita Federal."""
+    cnpj: str = Field(
+        ...,
+        description="Numero do CNPJ com 14 digitos numericos, com ou sem mascara de pontuacao.",
+        examples=["00.000.000/0001-91", "00000000000191"],
+    )
+
+
+class CepInput(BaseModel):
+    """Parametros para consulta de endereco postal e codigo IBGE por CEP."""
+    code: str = Field(
+        ...,
+        description="Codigo de CEP brasileiro com 8 digitos numericos, com ou sem hifen.",
+        examples=["01310-100", "01310100"],
+    )
+
+
+class DnsInput(BaseModel):
+    """Parametros para resolucao DNS autoritativa."""
+    domain: str = Field(
+        ...,
+        description="Nome de dominio da internet para resolucao de registros A, AAAA, MX, TXT, NS e CNAME.",
+        examples=["base.org", "ethereum.org"],
+    )
+
+
+class SslInput(BaseModel):
+    """Parametros para inspecao e auditoria de certificado TLS e SSL."""
+    host: str = Field(
+        ...,
+        description="Hostname ou dominio para inspecao de certificado TLS na porta 443.",
+        examples=["base.org", "google.com"],
+    )
+
+
+class AsnInput(BaseModel):
+    """Parametros para consulta de BGP e numero ASN."""
+    ip: Optional[str] = Field(
+        None,
+        description="Endereco IPv4 ou IPv6 a consultar. Se omitido, inspeciona o IP publico requisitante.",
+        examples=["1.1.1.1", "8.8.8.8"],
+    )
+
+
+class CryptoInput(BaseModel):
+    """Parametros opcionais para cotacao spot de criptoativos."""
+    symbol: Optional[str] = Field(
+        None,
+        description="Simbolo opcional do criptoativo (ex: BTC, ETH, SOL, USDC, BASE).",
+        examples=["BTC", "ETH"],
+    )
+
+
+class HolidaysInput(BaseModel):
+    """Parametros opcionais para consulta de feriados nacionais e bancarios."""
+    year: Optional[int] = Field(
+        None,
+        description="Ano calendario de 4 digitos entre 1900 e 2100. Se omitido, utiliza o ano corrente.",
+        ge=1900,
+        le=2100,
+        examples=[2026],
+    )
+
+
+class EconomicIndicators(BaseModel):
+    selic_target: float = Field(..., description="Taxa Selic meta anual em percentual.")
+    selic_daily: float = Field(..., description="Taxa Selic acumulada diaria anualizada.")
+    cdi_annual: float = Field(..., description="Taxa CDI anualizada em percentual.")
+    cdi_daily: float = Field(..., description="Taxa CDI diaria efetiva em percentual.")
+    ipca_12m: float = Field(..., description="IPCA acumulado nos ultimos 12 meses.")
+    ipca_monthly: float = Field(..., description="IPCA do ultimo mes fechado.")
+    reference_date: str = Field(..., description="Data de referencia dos indicadores diarios.")
+    ipca_reference_month: str = Field(..., description="Mes de referencia da divulgacao do IPCA.")
+
+
+class IndicatorsResponse(BaseModel):
+    status: str = Field(..., description="Status da consulta.")
+    service: str = Field("indicators", description="Nome do micro-servico.")
+    timestamp: str = Field(..., description="Data e hora ISO 8601 da resposta.")
+    indicators: EconomicIndicators = Field(..., description="Conjunto de indicadores economicos.")
+    source: str = Field(..., description="Fontes oficiais primarias.")
+    cached: Optional[bool] = Field(None, description="Indica se os dados foram servidos do cache.")
+
+
+class HolidayItem(BaseModel):
+    date: str = Field(..., description="Data do feriado no formato AAAA-MM-DD.")
+    name: str = Field(..., description="Nome oficial do feriado ou celebracao.")
+    type: str = Field(..., description="Tipo do feriado: national, banking ou religious.")
+    day_of_week: str = Field(..., description="Dia da semana correspondente em portugues.")
+    is_banking_holiday: bool = Field(..., description="Indica se nao ha expediente bancario ao publico.")
+
+
+class HolidaysResponse(BaseModel):
+    status: str = Field(..., description="Status da consulta.")
+    service: str = Field("holidays", description="Nome do micro-servico.")
+    year: int = Field(..., description="Ano calendario consultado.")
+    total_holidays: int = Field(..., description="Contagem total de feriados cadastrados no ano.")
+    holidays: list[HolidayItem] = Field(..., description="Lista de feriados ordenada cronologicamente.")
+    source: str = Field(..., description="Fontes oficiais primarias.")
+    cached: Optional[bool] = Field(None, description="Indica se os dados foram servidos do cache.")
+
+
+class SettlementInfo(BaseModel):
+    """Informacoes de liquidacao on-chain de micropagamento x402."""
+    settled: bool = Field(True, description="Indica se o pagamento foi liquidado com sucesso.")
+    tx_hash: str = Field(..., description="Hash da transacao confirmada na rede Base.")
+    price_usdc: str = Field(..., description="Valor pago em USDC.")
+    network: str = Field("Base", description="Rede blockchain da liquidacao.")
+    token: str = Field("USDC", description="Token utilizado no pagamento.")
+

grid402/py.typed

@@ -0,0 +1 @@
+

grid402-2.2.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: grid402
+Version: 2.2.0
+Summary: SDK Python oficial do Grid402: Micropagamentos HTTP 402 na Base para Agentes Autonomos e IA
+Author-email: Grid402 Team <contato@grid402.com.br>
+License-Expression: MIT
+Project-URL: Homepage, https://grid402.com.br
+Project-URL: Documentation, https://grid402.com.br/docs
+Project-URL: Repository, https://github.com/thiagobg90/Grid402
+Project-URL: Issues, https://github.com/thiagobg90/Grid402/issues
+Keywords: x402,http-402,micropayments,base,coinbase-agentkit,agentic-web,mcp,ai-agents
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# Grid402 - SDK Python Oficial
+
+Biblioteca Python oficial para consumo dos servicos do ecossistema **Grid402** e liquidacao autonoma de micropagamentos sob o protocolo HTTP 402 na rede Base.
+
+Projetada especificamente para agentes autonomos de inteligencia artificial, frameworks como Coinbase AgentKit, LangChain, CrewAI e desenvolvedores que buscam APIs abertas sem contas, cadastros ou cartoes de credito.
+
+---
+
+## Recursos Principais
+
+- **10 Ferramentas Integradas:** Indicadores macroeconomicos (Selic, CDI, IPCA), feriados nacionais e bancarios ANBIMA, CNPJ da Receita Federal, CEP postal e IBGE, cotacoes Forex e Cripto spot, resolucao DNS, auditoria TLS e SSL, analise ASN e BGP e status do ecossistema.
+- **Zero Cadastro e Zero Friccao:** Sem necessidade de chaves de API estaticas ou contratos mensais.
+- **Modo Sandbox Gratuito:** Teste e homologue localmente sem custos informando `sandbox=True`.
+- **Integracao Nativa com IA:** Compativel com Coinbase Developer Platform (CDP) AgentKit, LangChain e CrewAI.
+- **Validacao Estrita Pydantic:** Schemas tipados e compativeis com PEP 561 (`py.typed`).
+- **Arquitetura Resiliente:** Construido com a biblioteca padrao do Python para maxima leveza e portabilidade.
+
+---
+
+## Instalacao
+
+Instale o pacote diretamente do PyPI:
+
+```bash
+pip install grid402
+```
+
+---
+
+## Inicio Rapido
+
+### 1. Consultas em Modo Sandbox (Sem Custo)
+
+Ideal para testes locais, ambientes de integracao continua e desenvolvimento:
+
+```python
+from grid402 import Grid402Client
+
+# Inicializa o cliente apontando para o ambiente de testes gratuito
+client = Grid402Client(sandbox=True)
+
+# Consulta cadastral de Pessoa Juridica na Receita Federal
+cnpj_data = client.get_cnpj("00.000.000/0001-91")
+print("Razao Social:", cnpj_data.get("razao_social"))
+
+# Resolucao de endereco postal e codigo IBGE
+cep_data = client.get_cep("01310-100")
+print("Logradouro:", cep_data.get("logradouro"), "-", cep_data.get("localidade"))
+
+# Cotacoes fiduciarias oficiais
+forex_data = client.get_forex()
+print("USD para BRL:", forex_data.get("USD", {}).get("bid"))
+```
+
+---
+
+### 2. Tratamento Estruturado de HTTP 402
+
+Quando chamado sem comprovante de pagamento, o Grid402 retorna uma resposta estruturada contendo o desafio com pre-visualizacao parcial dos dados (teaser data):
+
+```python
+from grid402 import Grid402Client, Grid402PaymentRequiredError
+
+# Cliente com raise_for_payment ativado
+client = Grid402Client(raise_for_payment=True)
+
+try:
+    dados = client.get_cnpj("00000000000191")
+except Grid402PaymentRequiredError as erro:
+    print("Desafio recebido:")
+    print("Valor exigido:", erro.price_usdc, erro.token)
+    print("Carteira recebedora:", erro.recipient)
+    print("Rede:", erro.network)
+    print("Dados parciais (amostra gratuita):", erro.preview_data)
+```
+
+---
+
+### 3. Utilizacao com Coinbase AgentKit e Auto-Liquidacao
+
+Agentes autonomos equipados com carteiras CDP na rede Base podem liquidar chamadas M2M (Machine-to-Machine) de forma transparente:
+
+```python
+from grid402 import Grid402ActionProvider
+
+# Provedor compativel com Coinbase AgentKit
+provider = Grid402ActionProvider()
+
+# Ao fornecer a instancia de carteira CDP do agente (wallet_provider),
+# o provedor detecta o 402, transfere o USDC e repassa os dados completos
+resultado = provider.query_cnpj("00000000000191", wallet_provider=meu_wallet_provider)
+print("Dados completos:", resultado)
+print("Comprovante on-chain:", resultado.get("_x402_settlement"))
+```
+
+---
+
+### 4. Schemas Tipados Pydantic
+
+Para fluxos de trabalho tipados e validacao antecipada:
+
+```python
+from grid402 import CnpjInput, CepInput, DnsInput, SslInput, AsnInput, IndicatorsInput, HolidaysInput
+
+# Validacao de entrada antes do envio
+payload_cnpj = CnpjInput(cnpj="00.000.000/0001-91")
+payload_cep = CepInput(code="01310100")
+payload_dns = DnsInput(domain="base.org")
+payload_holidays = HolidaysInput(year=2026)
+```
+
+---
+
+## Catalogo de Ferramentas
+
+| Metodo | Descricao | Preco Base (USDC) |
+|---|---|---|
+| `get_summary()` | Resumo operacional consolidado de saude | Gratuito |
+| `get_forex()` | Cotacoes cambiais oficiais de USD, EUR e GBP para BRL | 0.0005 |
+| `get_crypto(symbol)` | Precos spot de BTC, ETH, SOL e USDC | 0.0005 |
+| `get_dns(domain)` | Resolucao DNS com registros A, AAAA, MX, TXT, NS e CNAME | 0.0005 |
+| `get_ssl(host)` | Inspecao e auditoria de certificado TLS e SSL na porta 443 | 0.0005 |
+| `get_asn(ip)` | Inteligencia de roteamento BGP, bloco alocado e ASN | 0.0005 |
+| `get_cep(code)` | Consulta de logradouro postal brasileiro e codigo IBGE | 0.0005 |
+| `get_cnpj(cnpj)` | Dados cadastrais completos de PJ na Receita Federal | 0.0020 |
+| `get_indicators()` | Indicadores macroeconomicos oficiais (Selic meta e diaria, CDI anual e IPCA) | 0.0005 |
+| `get_holidays(year)` | Calendario oficial de feriados nacionais e bancarios ANBIMA | 0.0005 |
+
+---
+
+## Licenca
+
+Distribuido sob os termos da licenca MIT. Consulte o arquivo `LICENSE` para detalhes.
+

grid402-2.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+grid402/__init__.py,sha256=p1HZHRS9O0uzEnkDmT3AVupBNuNvrz27AIv7QUfPw4s,1115
+grid402/agentkit.py,sha256=omtsTx_HKb9fl8hAUj-FzIP5H1arYT_xJTQb9WTXsrU,8126
+grid402/client.py,sha256=LB5ywWrCw_-uqsAMPr8t_dici3M4CvcBRV2_YSHYJrI,6652
+grid402/exceptions.py,sha256=VLcNcFvMOj4LiacXDaZHgGaFtKSk2QJ_TZ1hwB6WG70,1224
+grid402/models.py,sha256=BqS4IVxc1ya1TDleqoDbul2wNkRXJd_FheNYKVHHYIg,5092
+grid402/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+grid402-2.2.0.dist-info/licenses/LICENSE,sha256=AygoXt4UY-kO63c6vOPbjBDt_5pr7-fPv8qbaP6kvTk,1078
+grid402-2.2.0.dist-info/METADATA,sha256=c6w1sM9_TL9toCZgp91_Jn36pAXNRPy0h9WDC3quaQc,6453
+grid402-2.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+grid402-2.2.0.dist-info/top_level.txt,sha256=_7wfocziRC4JW_lvgWdBsKMB-1Uf3gBOiSa3fFSpGEk,8
+grid402-2.2.0.dist-info/RECORD,,

grid402-2.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

grid402-2.2.0.dist-info/licenses/LICENSE

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

grid402-2.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+grid402