Add Agent Payments in 2 Minutes

import requests
import json

# minia2a.uk — Agent-to-agent micropayments in USDC on Base
# pip install requests

class Minia2aClient:
    """Lightweight client for minia2a.uk — 174 x402-payable services."""

    def __init__(self, wallet: str, base_url: str = "https://minia2a.uk"):
        self.wallet = wallet
        self.base_url = base_url
        self.session = requests.Session()

    def _call(self, endpoint: str, params: dict = None) -> dict:
        """Make a pay-per-call request. Credits auto-deduct from wallet."""
        if params is None:
            params = {}
        params["wallet"] = self.wallet
        url = f"{self.base_url}/x402/{endpoint}"
        r = self.session.get(url, params=params, timeout=30)
        r.raise_for_status()
        return r.json()

    def gas_prices(self) -> dict:
        """Multi-chain gas prices — free"""
        return self._call("gas")

    def token_security(self, address: str) -> dict:
        """Scan a token for honeypot, ownership, liquidity risks — 1 credit"""
        return self._call("token-security", {"address": address})

    def web_scrape(self, url: str) -> dict:
        """Scrape any webpage — 1 credit"""
        return self._call("web-scrape", {"url": url})

    def dns_lookup(self, domain: str) -> dict:
        """DNS records (A, AAAA, MX, TXT, NS) — 1 credit"""
        return self._call("dns", {"domain": domain})

    def email_verify(self, email: str) -> dict:
        """Verify email deliverability — 1 credit"""
        return self._call("email-verify", {"email": email})

    def credits_balance(self) -> dict:
        """Check remaining credits"""
        r = self.session.get(
            f"{self.base_url}/api/my-credits",
            params={"wallet": self.wallet}
        )
        return r.json()


# ── Usage ──
if __name__ == "__main__":
    # 1. Register: POST /api/v1/register-simple {"name":"my-agent"}
    # 2. Save the wallet address, use it here
    client = Minia2aClient(wallet="0xYOUR_WALLET_ADDRESS")

    # Free call — no credits needed
    gas = client.gas_prices()
    print(f"⚡ Base gas: {gas.get('base',{}).get('gwei','?')} Gwei")

    # 1 credit each
    security = client.token_security("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")
    print(f"🔐 USDC security: {security.get('verdict','?')}")

    balance = client.credits_balance()
    print(f"💰 Credits: {balance.get('credits','?')}")

// minia2a.uk — Agent-to-agent micropayments in USDC on Base
// npm install node-fetch (Node <18) or use built-in fetch (Node 18+)

class Minia2aClient {
  /** Lightweight client for minia2a.uk — 174 x402-payable services */
  constructor(wallet, baseUrl = 'https://minia2a.uk') {
    this.wallet = wallet;
    this.baseUrl = baseUrl;
  }

  async _call(endpoint, params = {}) {
    const url = new URL(`/x402/${endpoint}`, this.baseUrl);
    url.searchParams.set('wallet', this.wallet);
    for (const [k, v] of Object.entries(params)) {
      url.searchParams.set(k, v);
    }
    const r = await fetch(url);
    if (!r.ok) throw new Error(`HTTP ${r.status}`);
    return r.json();
  }

  // Multi-chain gas prices — free
  async gasPrices() { return this._call('gas'); }

  // Token security scan — 1 credit
  async tokenSecurity(address) {
    return this._call('token-security', { address });
  }

  // Web scraping — 1 credit
  async webScrape(url) {
    return this._call('web-scrape', { url });
  }

  // DNS lookup — 1 credit
  async dnsLookup(domain) {
    return this._call('dns', { domain });
  }

  // IP geolocation — 1 credit
  async ipLookup(ip) {
    return this._call('ip-lookup', { ip });
  }

  // ENS resolution — 1 credit
  async ensResolve(name) {
    return this._call('ens-resolve', { name });
  }

  // Check credit balance
  async creditsBalance() {
    const url = `${this.baseUrl}/api/my-credits?wallet=${this.wallet}`;
    const r = await fetch(url);
    return r.json();
  }
}

// ── Usage ──
(async () => {
  // 1. Register: POST /api/v1/register-simple {"name":"my-agent"}
  // 2. Save the wallet address, use it here
  const client = new Minia2aClient('0xYOUR_WALLET_ADDRESS');

  // Free call
  const gas = await client.gasPrices();
  console.log('⚡ Gas:', gas);

  // 1 credit each
  const sec = await client.tokenSecurity('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48');
  console.log('🔐 USDC:', sec);

  const bal = await client.creditsBalance();
  console.log('💰 Credits:', bal);
})();

# minia2a.uk — Use x402 services as LangChain Tools
# pip install langchain requests

from langchain.tools import BaseTool
from pydantic import BaseModel, Field
import requests
from typing import Type

class TokenSecurityInput(BaseModel):
    address: str = Field(description="ERC-20 token contract address, e.g. 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")

class TokenSecurityTool(BaseTool):
    name: str = "token_security_scan"
    description: str = "Scan a token for honeypot, ownership concentration, liquidity risks. Costs 1 credit (~$0.005)."
    args_schema: Type[BaseModel] = TokenSecurityInput
    wallet: str = Field(default="")

    def _run(self, address: str) -> str:
        url = f"https://minia2a.uk/x402/token-security?wallet={self.wallet}&address={address}"
        r = requests.get(url, timeout=30)
        return str(r.json())

class WebScrapeInput(BaseModel):
    url: str = Field(description="Full URL to scrape and extract text from")

class WebScrapeTool(BaseTool):
    name: str = "web_scrape"
    description: str = "Scrape and extract text content from any webpage. Costs 1 credit (~$0.005)."
    args_schema: Type[BaseModel] = WebScrapeInput
    wallet: str = Field(default="")

    def _run(self, url: str) -> str:
        r = requests.get(
            f"https://minia2a.uk/x402/web-scrape",
            params={"wallet": self.wallet, "url": url},
            timeout=30
        )
        return str(r.json())

class GasPriceInput(BaseModel):
    pass  # No params needed

class GasPriceTool(BaseTool):
    name: str = "gas_prices"
    description: str = "Get current gas prices across Ethereum, Base, Arbitrum, Optimism, and more. FREE — no credits needed."
    args_schema: Type[BaseModel] = GasPriceInput
    wallet: str = Field(default="")

    def _run(self) -> str:
        r = requests.get(f"https://minia2a.uk/x402/gas?wallet={self.wallet}", timeout=30)
        return str(r.json())


# ── Wire into your agent ──
from langchain.agents import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI

WALLET = "0xYOUR_WALLET_ADDRESS"

tools = [
    TokenSecurityTool(wallet=WALLET),
    WebScrapeTool(wallet=WALLET),
    GasPriceTool(wallet=WALLET),
]

llm = ChatOpenAI(model="gpt-4o")
agent = initialize_agent(
    tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True
)

# Now your agent can scan tokens, scrape websites, and check gas — all paid in USDC
agent.run("Is the USDC token (0xA0b8...) safe? Check it on-chain and tell me current gas prices.")