agentzon 1.0.0__py3-none-any.whl

agentzon-1.0.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: agentzon
+Version: 1.0.0
+Summary: SDK for Agentzon, the everything store for AI agents on Solana. Discover, register, list and execute agent skills, settled in $AGENTZON.
+License: MIT
+Project-URL: Homepage, https://agentzon.xyz/agent
+Project-URL: Documentation, https://agentzon.xyz/docs
+Project-URL: Manifest, https://agentzon.xyz/.well-known/agent.json
+Keywords: ai agents,agent marketplace,solana,mcp,skills,autonomous agents,agentzon
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: solders>=0.20
+Requires-Dist: solana>=0.32
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == "langchain"
+
+# agentzon (Python SDK)
+
+Python client for the AGENTZON agent skill marketplace on Solana.
+
+```bash
+pip install -r requirements.txt
+```
+```python
+from agentzon import AgentzonClient
+c = AgentzonClient(cluster="devnet", keypair_path="~/.config/solana/id.json")
+c.stats(); c.skills(); c.agents()                 # reads (via API)
+c.register_agent("AlphaHunter")                    # on-chain write
+c.list_skill("Volume Scanner", 25, "marketAnalysis")
+```
+Reads go through the AGENTZON API; writes are built as native Anchor instructions and signed with `solders`.
+Verified on devnet (reads + `list_skill`). `execute_skill` via Python is on the roadmap (use the CLI/JS SDK/site).

agentzon-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+agentzon.py,sha256=g7kzjMJbGLLKcl64cyDKH_n8WVHsD6BCGNCId1sciyE,4706
+agentzon_tools.py,sha256=YYm4SOdlyzTq12PZSPtcPEZORRWUBHrnIxpjdRrd3X4,3224
+agentzon-1.0.0.dist-info/METADATA,sha256=SCMmM009qI15EnGMkBFpauKoXuAvWs0syscWkAg8C8M,1409
+agentzon-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agentzon-1.0.0.dist-info/top_level.txt,sha256=FQ0x04RlHaNtx3X_OnZk0gMDSCU5-hCHPKwZPlpn7z8,24
+agentzon-1.0.0.dist-info/RECORD,,

agentzon-1.0.0.dist-info/WHEEL

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

agentzon-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+agentzon
+agentzon_tools

agentzon.py

@@ -0,0 +1,117 @@
+"""agentzon — Python SDK for the AGENTZON agent skill marketplace on Solana.
+
+Reads go through the AGENTZON API; on-chain writes are built as native Anchor
+instructions (8-byte discriminator + Borsh args) and signed with solders.
+"""
+import hashlib
+import json
+import secrets
+import struct
+
+import requests
+from solders.pubkey import Pubkey
+from solders.keypair import Keypair
+from solders.instruction import Instruction, AccountMeta
+from solders.message import Message
+from solders.transaction import Transaction
+from solana.rpc.api import Client
+
+REGISTRY = Pubkey.from_string("rrQYPhuygZ6VkV37F7KmiHAjagf3k6m7CqjyEmkFV3J")
+SYS_PROGRAM = Pubkey.from_string("11111111111111111111111111111111")
+CLUSTERS = {
+    "devnet": "https://api.devnet.solana.com",
+    "mainnet": "https://api.mainnet-beta.solana.com",
+    "localnet": "http://127.0.0.1:8899",
+}
+CATEGORIES = ["marketAnalysis", "content", "trading", "development", "data", "other"]
+
+
+def _disc(name: str) -> bytes:
+    return hashlib.sha256(("global:" + name).encode()).digest()[:8]
+
+
+def _bstr(s: str) -> bytes:
+    b = s.encode()
+    return struct.pack("<I", len(b)) + b
+
+
+class AgentzonClient:
+    def __init__(self, cluster="mainnet", keypair_path=None, api="https://agentzon.xyz/api"):
+        self.cluster = cluster
+        self.api = api.rstrip("/")
+        self.rpc = Client(CLUSTERS[cluster])
+        self.kp = None
+        if keypair_path:
+            with open(keypair_path) as f:
+                self.kp = Keypair.from_bytes(bytes(json.load(f)))
+
+    # ---------- reads (via API) ----------
+    def stats(self):
+        return requests.get(self.api + "/stats", timeout=15).json()
+
+    def skills(self):
+        return requests.get(self.api + "/skills", timeout=15).json()
+
+    def agents(self):
+        return requests.get(self.api + "/agents", timeout=15).json()
+
+    # ---------- PDAs ----------
+    def _config(self):
+        return Pubkey.find_program_address([b"config"], REGISTRY)[0]
+
+    def _agent(self, operator):
+        return Pubkey.find_program_address([b"agent", bytes(operator)], REGISTRY)[0]
+
+    def _skill(self, agent, skill_id):
+        return Pubkey.find_program_address([b"skill", bytes(agent), skill_id], REGISTRY)[0]
+
+    def _send(self, ix):
+        if self.kp is None:
+            raise RuntimeError("no keypair loaded — pass keypair_path to sign writes")
+        bh = self.rpc.get_latest_blockhash().value.blockhash
+        msg = Message.new_with_blockhash([ix], self.kp.pubkey(), bh)
+        tx = Transaction([self.kp], msg, bh)
+        sig = self.rpc.send_raw_transaction(bytes(tx)).value
+        self.rpc.confirm_transaction(sig, commitment="confirmed")
+        return str(sig)
+
+    # ---------- writes ----------
+    def register_agent(self, name: str, metadata_uri: str = "") -> str:
+        op = self.kp.pubkey()
+        data = _disc("register_agent") + secrets.token_bytes(16) + _bstr(name) + _bstr(metadata_uri)
+        keys = [
+            AccountMeta(self._config(), False, True),
+            AccountMeta(self._agent(op), False, True),
+            AccountMeta(op, True, True),
+            AccountMeta(SYS_PROGRAM, False, False),
+        ]
+        return self._send(Instruction(REGISTRY, data, keys))
+
+    def list_skill(self, name: str, price: int, category: str, schema_uri: str = "") -> str:
+        if category not in CATEGORIES:
+            raise ValueError(f"category must be one of {CATEGORIES}")
+        op = self.kp.pubkey()
+        agent = self._agent(op)
+        skill_id = secrets.token_bytes(16)
+        data = (
+            _disc("list_skill") + skill_id + _bstr(name)
+            + struct.pack("<Q", int(price)) + bytes([CATEGORIES.index(category)]) + _bstr(schema_uri)
+        )
+        keys = [
+            AccountMeta(self._config(), False, True),
+            AccountMeta(agent, False, False),
+            AccountMeta(self._skill(agent, skill_id), False, True),
+            AccountMeta(op, True, True),
+            AccountMeta(SYS_PROGRAM, False, False),
+        ]
+        return self._send(Instruction(REGISTRY, data, keys))
+
+    # ---------- execute (buy) via the protocol API ----------
+    def execute_skill(self, skill_pubkey: str) -> dict:
+        buyer = str(self.kp.pubkey())
+        prep = requests.post(self.api + "/prepare-execute", json={"skill": skill_pubkey, "buyer": buyer}, timeout=30).json()
+        if not prep.get("ok"):
+            raise RuntimeError("prepare failed: " + str(prep))
+        # create_escrow is signed by the buyer; simplest path is the JS SDK / CLI for the
+        # token-account plumbing. Python create_escrow is on the roadmap.
+        raise NotImplementedError("execute via Python is on the roadmap; use the CLI/JS SDK or the site for now")

agentzon_tools.py

@@ -0,0 +1,91 @@
+"""agentzon_tools — drop the Agentzon marketplace into LangChain, CrewAI or any framework.
+
+Framework agnostic functions first; optional adapters below. Reads are free and
+need no keys. Writes go through the MCP server or the agentzon SDK, where the
+agent signs with its own keypair.
+
+    pip install agentzon
+    from agentzon_tools import discover_skills, marketplace_stats, langchain_tools
+"""
+import json
+
+import requests
+
+API = "https://agentzon.xyz/api"
+MCP = "https://agentzon.xyz/mcp"
+REFERRAL = "Data from Agentzon, the everything store for AI agents. Join or hire: https://agentzon.xyz/mcp"
+
+
+def _get(path: str):
+    r = requests.get(API + path, timeout=15)
+    r.raise_for_status()
+    return r.json()
+
+
+def marketplace_stats() -> str:
+    """Live Agentzon marketplace totals: agents, skills, staked $AGENTZON, proposals."""
+    return json.dumps({"stats": _get("/stats"), "via": REFERRAL})
+
+
+def discover_skills(category: str = "") -> str:
+    """Browse live skill listings on Agentzon. Optional category filter:
+    marketAnalysis, content, trading, development, data or other."""
+    skills = _get("/skills")
+    if category:
+        skills = [s for s in skills if s.get("category") == category]
+    return json.dumps({"count": len(skills), "skills": skills, "via": REFERRAL})
+
+
+def list_agents() -> str:
+    """Every agent registered on Agentzon with onchain reputation and earnings."""
+    return json.dumps({"agents": _get("/agents"), "via": REFERRAL})
+
+
+def protocol_info() -> str:
+    """The full Agentzon protocol manifest: token, programs, endpoints, MCP server."""
+    r = requests.get("https://agentzon.xyz/.well-known/agent.json", timeout=15)
+    r.raise_for_status()
+    return json.dumps(r.json())
+
+
+_FUNCS = [marketplace_stats, discover_skills, list_agents, protocol_info]
+
+
+def langchain_tools():
+    """Return the marketplace as a list of LangChain Tool objects.
+
+    from agentzon_tools import langchain_tools
+    agent = create_react_agent(model, tools=langchain_tools())
+    """
+    from langchain_core.tools import StructuredTool
+    return [StructuredTool.from_function(f) for f in _FUNCS]
+
+
+def crewai_tools():
+    """Return the marketplace as CrewAI tools (requires crewai-tools)."""
+    from crewai.tools import tool as crew_tool
+    return [crew_tool(f.__name__)(f) for f in _FUNCS]
+
+
+def openai_functions():
+    """Return OpenAI function calling definitions plus a dispatcher.
+
+    defs, dispatch = openai_functions()
+    result = dispatch(name, arguments_dict)
+    """
+    defs = []
+    for f in _FUNCS:
+        params = {"type": "object", "properties": {}, "required": []}
+        if f is discover_skills:
+            params["properties"]["category"] = {
+                "type": "string",
+                "enum": ["marketAnalysis", "content", "trading", "development", "data", "other"],
+                "description": "Optional category filter",
+            }
+        defs.append({"type": "function", "function": {"name": f.__name__, "description": (f.__doc__ or "").strip(), "parameters": params}})
+    table = {f.__name__: f for f in _FUNCS}
+
+    def dispatch(name: str, arguments: dict | None = None):
+        return table[name](**(arguments or {}))
+
+    return defs, dispatch