m2mcent-sdk 1.0.3__py3-none-any.whl

m2mcent/__init__.py

@@ -0,0 +1,4 @@
+from .client import M2MClient, M2MCentClient
+from .langchain_toolkit import M2MCentToolkit
+
+__all__ = ["M2MClient", "M2MCentClient", "M2MCentToolkit"]

m2mcent/client.py

@@ -0,0 +1,164 @@
+import requests
+import base64
+import json
+import time
+import secrets
+from eth_account import Account
+from eth_account.messages import encode_typed_data
+
+
+class M2MClient:
+    """
+    M2MCent SDK Client (Python v2.0 - x402 V2 Compliant)
+    Implements automated x402 V2 EIP-3009 payment protocol on Base Mainnet (8453).
+    """
+
+    ESCROW_ADDRESS = "0x5d47070A36A37DAf417e64FF27a1e5B3F1c84efa"
+    TREASURY_ADDRESS = "0x8aaBAB75bE8825d0f5D514a9a5cBa04B7bF84920"
+    USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+    CHAIN_ID = 8453  # Base Mainnet
+
+    USDC_DOMAIN_NAME = "USD Coin"
+    USDC_VERSION = "2"
+
+    def __init__(self, private_key: str, rpc_url: str = "https://mainnet.base.org", gateway_url: str = "https://api.m2mcent.com"):
+        clean_key = private_key if private_key.startswith("0x") else f"0x{private_key}"
+        self.account = Account.from_key(clean_key)
+        self.rpc_url = rpc_url
+        self.gateway_url = gateway_url.rstrip("/")
+
+    def _parse_402_challenge(self, response: requests.Response) -> dict:
+        header_b64 = response.headers.get("Payment-Required") or response.headers.get("payment-required")
+        if header_b64:
+            try:
+                decoded = json.loads(base64.b64decode(header_b64).decode("utf-8"))
+                accepts = decoded.get("accepts") or []
+                if accepts:
+                    acc = accepts[0]
+                    amount = acc.get("amount") or acc.get("maxAmountRequired")
+                    if amount:
+                        return {
+                            "amountRaw": int(amount),
+                            "escrow": acc.get("escrow") or (acc.get("extra") or {}).get("escrow") or acc.get("payTo") or self.ESCROW_ADDRESS,
+                            "asset": acc.get("asset") or self.USDC_ADDRESS,
+                        }
+                if decoded.get("amountRaw"):
+                    return {
+                        "amountRaw": int(decoded["amountRaw"]),
+                        "escrow": decoded.get("escrow") or self.ESCROW_ADDRESS,
+                        "asset": decoded.get("contract") or self.USDC_ADDRESS,
+                    }
+            except Exception:
+                pass
+
+        try:
+            body = response.json()
+        except Exception:
+            body = {}
+
+        challenge = body.get("challenge") or {}
+        if challenge.get("amount"):
+            return {
+                "amountRaw": int(challenge["amount"]),
+                "escrow": challenge.get("escrow") or self.ESCROW_ADDRESS,
+                "asset": challenge.get("asset") or self.USDC_ADDRESS,
+            }
+
+        price_hdr = response.headers.get("x-402-price")
+        if price_hdr:
+            return {
+                "amountRaw": int(round(float(price_hdr) * 1_000_000)),
+                "escrow": response.headers.get("x-402-contract") or self.ESCROW_ADDRESS,
+                "asset": self.USDC_ADDRESS,
+            }
+
+        raise ValueError("Unable to parse HTTP 402 x402 V2 challenge from response.")
+
+    def _sign_authorization(self, challenge_meta: dict) -> str:
+        amount_raw = int(challenge_meta["amountRaw"])
+        escrow_addr = challenge_meta.get("escrow") or self.ESCROW_ADDRESS
+        usdc_addr = challenge_meta.get("asset") or self.USDC_ADDRESS
+
+        domain = {
+            "name": self.USDC_DOMAIN_NAME,
+            "version": self.USDC_VERSION,
+            "chainId": self.CHAIN_ID,
+            "verifyingContract": usdc_addr,
+        }
+
+        types = {
+            "TransferWithAuthorization": [
+                {"name": "from", "type": "address"},
+                {"name": "to", "type": "address"},
+                {"name": "value", "type": "uint256"},
+                {"name": "validAfter", "type": "uint256"},
+                {"name": "validBefore", "type": "uint256"},
+                {"name": "nonce", "type": "bytes32"},
+            ]
+        }
+
+        valid_after = 0
+        valid_before = int(time.time()) + 3600
+        nonce_hex = "0x" + secrets.token_hex(32)
+
+        message = {
+            "from": self.account.address,
+            "to": escrow_addr,
+            "value": amount_raw,
+            "validAfter": valid_after,
+            "validBefore": valid_before,
+            "nonce": nonce_hex,
+        }
+
+        signable_message = encode_typed_data(domain_data=domain, message_types=types, message_data=message)
+        signed = self.account.sign_message(signable_message)
+        sig_hex = signed.signature.hex()
+        if not sig_hex.startswith("0x"):
+            sig_hex = "0x" + sig_hex
+
+        auth_str = {
+            "from": self.account.address,
+            "to": escrow_addr,
+            "value": str(amount_raw),
+            "validAfter": valid_after,
+            "validBefore": valid_before,
+            "nonce": nonce_hex,
+        }
+
+        payload = {
+            "x402Version": 2,
+            "scheme": "exact",
+            "network": f"eip155:{self.CHAIN_ID}",
+            "payload": {
+                "signature": sig_hex,
+                "authorization": auth_str,
+            },
+            **auth_str,
+            "signature": sig_hex,
+        }
+
+        return base64.b64encode(json.dumps(payload).encode("utf-8")).decode("utf-8")
+
+    def request(self, method: str, url: str, max_retries: int = 2, **kwargs) -> requests.Response:
+        response = requests.request(method, url, **kwargs)
+
+        if response.status_code == 402:
+            challenge_meta = self._parse_402_challenge(response)
+            sig_payload_b64 = self._sign_authorization(challenge_meta)
+
+            headers = dict(kwargs.get("headers") or {})
+            headers["Payment-Signature"] = sig_payload_b64
+            headers["x-payment"] = sig_payload_b64
+            kwargs["headers"] = headers
+
+            for i in range(max_retries):
+                retry_resp = requests.request(method, url, **kwargs)
+                if retry_resp.status_code != 402:
+                    return retry_resp
+                time.sleep((i + 1) * 1.5)
+            return retry_resp
+
+        return response
+
+
+M2MCentClient = M2MClient

m2mcent/langchain_toolkit.py

@@ -0,0 +1,93 @@
+"""
+M2MCent LangChain & LangGraph Toolkit (x402 V2 Compliant)
+Enables autonomous LangChain agents to discover, preview, quote, and invoke 1,057+
+monetized deterministic x402 tools on Base Mainnet (chainId: 8453).
+
+Smart Contract Escrow: 0x5d47070A36A37DAf417e64FF27a1e5B3F1c84efa
+Institutional Safe Treasury: 0x8aaBAB75bE8825d0f5D514a9a5cBa04B7bF84920
+Vouch Protocol: Grade A (100/100) Certified | Post-Quantum ML-DSA-65 Ready
+"""
+import requests
+from typing import List, Dict, Any, Optional
+from .client import M2MClient
+
+ESCROW_CONTRACT_ADDRESS = "0x5d47070A36A37DAf417e64FF27a1e5B3F1c84efa"
+TREASURY_SAFE_ADDRESS = "0x8aaBAB75bE8825d0f5D514a9a5cBa04B7bF84920"
+
+
+class M2MCentToolkit:
+    def __init__(
+        self,
+        gateway_url: str = "https://api.m2mcent.com",
+        private_key: Optional[str] = None,
+        rpc_url: str = "https://mainnet.base.org",
+    ):
+        self.gateway_url = gateway_url.rstrip("/")
+        self.private_key = private_key
+        self.client = M2MClient(private_key, rpc_url=rpc_url, gateway_url=self.gateway_url) if private_key else None
+        self._tools_cache: List[Dict[str, Any]] = []
+
+    def _normalize_slug(self, tool_name_or_slug: str) -> str:
+        # Support both underscore function names (autonomous_trading_bot_mcp) and slugs (autonomous-trading-bot-mcp)
+        if self._tools_cache:
+            for t in self._tools_cache:
+                if t.get("id") == tool_name_or_slug or t.get("name") == tool_name_or_slug:
+                    return t.get("id") or tool_name_or_slug.replace("_", "-")
+        return tool_name_or_slug.replace("_", "-")
+
+    def fetch_tools(self, limit: int = 1062) -> List[Dict[str, Any]]:
+        """Fetch available tools from M2MCent Gateway (/api/v1/tools)."""
+        resp = requests.get(f"{self.gateway_url}/api/v1/tools", params={"limit": limit}, timeout=10)
+        if resp.status_code == 200:
+            self._tools_cache = resp.json().get("tools", [])
+            return self._tools_cache
+        return []
+
+    def quote_tool(self, tool_name: str) -> Dict[str, Any]:
+        """Free pre-flight pricing quote (/:id/quote)."""
+        slug = self._normalize_slug(tool_name)
+        resp = requests.get(f"{self.gateway_url}/{slug}/quote", timeout=10)
+        return resp.json()
+
+    def preview_tool(self, tool_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Free syntactic schema validation & dry-run preview (/:id/api/preview)."""
+        slug = self._normalize_slug(tool_name)
+        resp = requests.post(f"{self.gateway_url}/{slug}/api/preview", json=payload, timeout=10)
+        return resp.json()
+
+    def call_tool(
+        self,
+        tool_name: str,
+        payload: Dict[str, Any],
+        payment_signature: Optional[str] = None,
+        validate_preview: bool = False,
+    ) -> Dict[str, Any]:
+        """Invoke an M2MCent deterministic tool on /{slug}/api/process with automatic EIP-3009 signing."""
+        slug = self._normalize_slug(tool_name)
+        if validate_preview:
+            prev = self.preview_tool(slug, payload)
+            if prev.get("status") == "VALIDATION_FAILED":
+                return prev
+
+        endpoint = f"{self.gateway_url}/{slug}/api/process"
+        headers = {"Content-Type": "application/json"}
+
+        if payment_signature:
+            headers["Payment-Signature"] = payment_signature
+            headers["x-payment"] = payment_signature
+            response = requests.post(endpoint, json=payload, headers=headers, timeout=20)
+            return response.json()
+
+        if self.client:
+            response = self.client.request("POST", endpoint, json=payload, headers=headers, timeout=20)
+            return response.json()
+
+        response = requests.post(endpoint, json=payload, headers=headers, timeout=20)
+        if response.status_code == 402:
+            return {
+                "status": "Payment Required",
+                "code": 402,
+                "challenge": response.headers.get("Payment-Required") or response.headers.get("payment-required"),
+                "details": response.json(),
+            }
+        return response.json()

m2mcent_sdk-1.0.3.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: m2mcent-sdk
+Version: 1.0.3
+Summary: Official Python SDK & LangChain Toolkit for M2MCent x402 V2 Protocol on Base Mainnet (1,057 Deterministic Nodes, Vouch Grade A)
+Author: M2MCent Protocol
+Author-email: hello@m2mcent.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: eth-account>=0.10.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🐍 m2mcent-sdk (v1.0.3)
+
+Official Python SDK (`M2MClient`, `M2MCentToolkit`) for the **M2MCent x402 V2 Protocol** on **Base Mainnet (`eip155:8453`)**.
+
+- **1,057 Deterministic Micro-Services** (`$0.010`–`$0.250` USDC, `<250ms` compute SLA)
+- **Vouch Trust Index:** Grade A (`100/100`) · Post-Quantum `ML-DSA-65` (FIPS 204)
+- **Smart Contract Escrow:** `0x5d47070A36A37DAf417e64FF27a1e5B3F1c84efa`
+- **Institutional Safe Treasury:** `0x8aaBAB75bE8825d0f5D514a9a5cBa04B7bF84920`
+
+## Installation
+```bash
+pip install m2mcent-sdk
+```
+
+## Quickstart
+```python
+from m2mcent import M2MCentToolkit
+
+tk = M2MCentToolkit(private_key="0xYOUR_BASE_WALLET_KEY")
+preview = tk.preview_tool("autonomous-trading-bot-mcp", {"symbol": "ETH"})
+result = tk.call_tool("autonomous-trading-bot-mcp", {"symbol": "ETH"}, validate_preview=True)
+```

m2mcent_sdk-1.0.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+m2mcent/__init__.py,sha256=PXwYzEciB4JNPHqXogEOnT5OaIee6iNHJGkqAS1Vo-8,151
+m2mcent/client.py,sha256=tpTIIWEVX5zcANc0VKmnbCcDVokpZ0DNwZuuYcxBSbo,6092
+m2mcent/langchain_toolkit.py,sha256=rrdzqRjM5eAHKumOX4p2v98xSdQYWL7mfYEIn808l9I,4118
+m2mcent_sdk-1.0.3.dist-info/METADATA,sha256=KDEC45KWCq9H7zRPX4Jda_6W6FJWLJtp6bIn6z9Clkw,1407
+m2mcent_sdk-1.0.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+m2mcent_sdk-1.0.3.dist-info/top_level.txt,sha256=GyzUN_y3yc2Zlr-FBRQ0StpaNTqUVrBDKXol6G-u8pw,8
+m2mcent_sdk-1.0.3.dist-info/RECORD,,

m2mcent_sdk-1.0.3.dist-info/WHEEL

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

m2mcent_sdk-1.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+m2mcent