nexum-sdk 0.1.0__tar.gz

nexum_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: nexum-sdk
+Version: 0.1.0
+Summary: Official Python SDK for NEXUM Protocol on Solana
+Author-email: NEXUM Protocol <protocolnexum@gmail.com>
+License: MIT
+Project-URL: Homepage, https://nexum-protocol.netlify.app
+Project-URL: Repository, https://github.com/Nexumprotocol/nexum-sdk
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: base58>=2.1.1
+Requires-Dist: solders>=0.21.0

nexum_sdk-0.1.0/README.md

@@ -0,0 +1,124 @@
+# nexum-sdk (Python)
+
+Official Python SDK for [NEXUM Protocol](https://nexum-protocol.netlify.app) — a decentralized freelance marketplace built on Solana.
+
+## Installation
+
+```bash
+pip install nexum-sdk
+```
+
+## Requirements
+
+- Python 3.10+
+- Dependencies: `httpx`, `base58`, `solders`
+
+## Quick Start
+
+```python
+from nexum_sdk import NexumClient, Network
+
+# Connect to devnet
+client = NexumClient.devnet()
+
+# Connect to mainnet
+client = NexumClient.mainnet()
+
+# Custom RPC
+client = NexumClient(network=Network.DEVNET, rpc_url="https://your-custom-rpc.com")
+```
+
+## Tasks (async)
+
+```python
+import asyncio
+from nexum_sdk import NexumClient, TaskStatus
+
+client = NexumClient.devnet()
+
+async def main():
+    # Fetch all open tasks
+    tasks = await client.get_open_tasks()
+    for task in tasks:
+        print(task.title, task.reward_sol, "SOL")
+        print(task.skills_list)   # ['Rust', 'Solana']
+
+    # Fetch a specific task
+    task = await client.get_task(1)
+    if task:
+        print(task.title)
+        print(task.status)        # TaskStatus.OPEN
+
+    # Fetch all tasks
+    all_tasks = await client.get_all_tasks()
+
+    # Total value locked
+    tvl = await client.get_tvl()
+    print(f"TVL: {tvl:.2f} SOL")
+
+asyncio.run(main())
+```
+
+## Tasks (sync helpers)
+
+```python
+client = NexumClient.devnet()
+
+# Synchronous wrappers — no async/await needed
+tasks = client.get_all_tasks_sync()
+tvl   = client.get_tvl_sync()
+```
+
+## Utilities
+
+```python
+from nexum_sdk import (
+    sol_to_lamports,
+    lamports_to_sol,
+    get_sbt_level,
+    get_sbt_label,
+    days_left,
+    short_address,
+)
+
+sol_to_lamports(1.5)          # 1500000000
+lamports_to_sol(1_000_000_000) # 1.0
+
+get_sbt_level(20)             # 3
+get_sbt_label(3)              # "Expert"
+
+days_left(deadline_unix)      # 7
+
+short_address("7yn8tuqH...NNzA")  # "7yn8...NNzA"
+```
+
+## Constants
+
+```python
+from nexum_sdk import (
+    NEXUM_PROGRAM_ID,
+    NEXUM_DEVNET_RPC,
+    PLATFORM_FEE_BPS,
+    SBT_LEVELS,
+)
+```
+
+## Types
+
+```python
+from nexum_sdk import NexumTask, NexumProfile, NexumDispute, TaskStatus, Network, TaskFilter
+
+# Filter tasks
+filter_ = TaskFilter(status=TaskStatus.IN_PROGRESS)
+tasks = await client.get_all_tasks(filter_)
+```
+
+## Links
+
+- [NEXUM Protocol](https://nexum-protocol.netlify.app)
+- [GitHub](https://github.com/Nexumprotocol/nexum-sdk)
+- [PyPI](https://pypi.org/project/nexum-sdk)
+
+## License
+
+MIT

nexum_sdk-0.1.0/nexum_sdk/__init__.py

@@ -0,0 +1,6 @@
+from .client import NexumClient
+from .types import NexumTask, NexumProfile, NexumDispute, TaskStatus, Network, TaskFilter
+from .constants import NEXUM_PROGRAM_ID, NEXUM_DEVNET_RPC, PLATFORM_FEE_BPS, SBT_LEVELS
+from .utils import sol_to_lamports, lamports_to_sol, get_sbt_level, get_sbt_label, days_left, short_address
+
+__version__ = "0.1.0"

nexum_sdk-0.1.0/nexum_sdk/client.py

@@ -0,0 +1,77 @@
+import struct, asyncio, base64
+from typing import Optional, List
+import httpx
+from .constants import NEXUM_PROGRAM_ID, NEXUM_DEVNET_RPC, NEXUM_MAINNET_RPC
+from .types import NexumTask, NexumProfile, NexumDispute, TaskStatus, Network, TaskFilter
+
+class NexumClient:
+    def __init__(self, network=Network.DEVNET, rpc_url=None):
+        self.network = network
+        self.program_id = NEXUM_PROGRAM_ID
+        self.rpc_url = rpc_url or (NEXUM_DEVNET_RPC if network == Network.DEVNET else NEXUM_MAINNET_RPC)
+
+    @classmethod
+    def devnet(cls, rpc_url=None): return cls(Network.DEVNET, rpc_url)
+    @classmethod
+    def mainnet(cls, rpc_url=None): return cls(Network.MAINNET, rpc_url)
+
+    async def _rpc(self, method, params):
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.post(self.rpc_url, json={"jsonrpc":"2.0","id":1,"method":method,"params":params})
+            return r.json().get("result")
+
+    async def get_open_tasks(self): return await self.get_all_tasks(TaskFilter(status=TaskStatus.OPEN))
+
+    async def get_all_tasks(self, filter_=None):
+        result = await self._rpc("getProgramAccounts",[self.program_id,{"encoding":"base64","filters":[{"dataSize":892}]}])
+        if not result: return []
+        tasks = []
+        for item in result:
+            try:
+                data = base64.b64decode(item["account"]["data"][0])
+                tasks.append(self._deserialize_task(data))
+            except: continue
+        if filter_ and filter_.status:
+            tasks = [t for t in tasks if t.status == filter_.status]
+        return tasks
+
+    async def get_task(self, task_id):
+        try:
+            from .utils import sol_to_lamports
+            from solders.pubkey import Pubkey
+            import struct
+            id_bytes = struct.pack('<Q', task_id)
+            pda, _ = Pubkey.find_program_address([b"task", id_bytes], Pubkey.from_string(self.program_id))
+            result = await self._rpc("getAccountInfo",[str(pda),{"encoding":"base64"}])
+            if not result or not result.get("value"): return None
+            data = base64.b64decode(result["value"]["data"][0])
+            return self._deserialize_task(data)
+        except: return None
+
+    async def get_tvl(self):
+        tasks = await self.get_all_tasks()
+        return sum(t.reward_sol for t in tasks if t.status in [TaskStatus.OPEN, TaskStatus.IN_PROGRESS])
+
+    def _deserialize_task(self, data):
+        o = 8
+        task_id = struct.unpack_from('<Q',data,o)[0]; o+=8
+        creator = self._pk(data,o); o+=32
+        tl=struct.unpack_from('<I',data,o)[0];o+=4; title=data[o:o+tl].decode();o+=tl
+        dl=struct.unpack_from('<I',data,o)[0];o+=4; desc=data[o:o+dl].decode();o+=dl
+        sl=struct.unpack_from('<I',data,o)[0];o+=4; skills=data[o:o+sl].decode();o+=sl
+        reward=struct.unpack_from('<Q',data,o)[0];o+=8
+        deadline=struct.unpack_from('<q',data,o)[0];o+=8
+        sm={0:TaskStatus.OPEN,1:TaskStatus.IN_PROGRESS,2:TaskStatus.COMPLETED,3:TaskStatus.DISPUTED,4:TaskStatus.CANCELLED}
+        status=sm.get(data[o],TaskStatus.OPEN);o+=1
+        hw=data[o]==1;o+=1
+        worker=self._pk(data,o) if hw else None
+        if hw: o+=32
+        bump=data[o];o+=1; eb=data[o]
+        return NexumTask(task_id,creator,title,desc,skills,reward,deadline,status,worker,bump,eb)
+
+    def _pk(self,data,o):
+        import base58
+        return base58.b58encode(data[o:o+32]).decode()
+
+    def get_all_tasks_sync(self, filter_=None): return asyncio.run(self.get_all_tasks(filter_))
+    def get_tvl_sync(self): return asyncio.run(self.get_tvl())

nexum_sdk-0.1.0/nexum_sdk/constants.py

@@ -0,0 +1,8 @@
+NEXUM_PROGRAM_ID  = "7yn8tuqHbNFRojEgiWeSoJkYjYtmdh1w4dKA2bCgNNzA"
+NEXUM_DEVNET_RPC  = "https://api.devnet.solana.com"
+NEXUM_MAINNET_RPC = "https://api.mainnet-beta.solana.com"
+PLATFORM_FEE_BPS  = 250
+LAMPORTS_PER_SOL  = 1_000_000_000
+SBT_LEVELS = {0:"Newcomer",1:"Contributor",2:"Builder",3:"Expert",4:"Legend"}
+SBT_THRESHOLDS = [0, 5, 15, 30, 50]
+SEEDS = {"task":b"task","escrow":b"escrow","profile":b"profile","dispute":b"dispute"}

nexum_sdk-0.1.0/nexum_sdk/types.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+class TaskStatus(str, Enum):
+    OPEN        = "open"
+    IN_PROGRESS = "inProgress"
+    COMPLETED   = "completed"
+    DISPUTED    = "disputed"
+    CANCELLED   = "cancelled"
+
+class Network(str, Enum):
+    DEVNET  = "devnet"
+    MAINNET = "mainnet-beta"
+
+@dataclass
+class NexumTask:
+    task_id: int; creator: str; title: str; description: str
+    required_skills: str; reward_lamports: int; deadline_unix: int
+    status: TaskStatus; worker: Optional[str]; bump: int; escrow_bump: int
+    @property
+    def reward_sol(self): return self.reward_lamports / 1_000_000_000
+    @property
+    def skills_list(self): return [s.strip() for s in self.required_skills.split(',')]
+
+@dataclass
+class NexumProfile:
+    owner: str; username: str; skills: str; reputation: int
+    tasks_completed: int; tasks_created: int; sbt_level: int; bump: int
+    @property
+    def sbt_label(self):
+        from .constants import SBT_LEVELS
+        return SBT_LEVELS.get(self.sbt_level, "Unknown")
+
+@dataclass
+class NexumDispute:
+    task_id: int; opened_by: str; reason: str; resolved: bool; bump: int
+
+@dataclass
+class TaskFilter:
+    status: Optional[TaskStatus] = None
+    creator: Optional[str] = None
+    worker: Optional[str] = None

nexum_sdk-0.1.0/nexum_sdk/utils.py

@@ -0,0 +1,15 @@
+import time, struct
+from .constants import LAMPORTS_PER_SOL, SBT_LEVELS, SBT_THRESHOLDS, PLATFORM_FEE_BPS
+
+def sol_to_lamports(sol): return int(sol * LAMPORTS_PER_SOL)
+def lamports_to_sol(lamps): return lamps / LAMPORTS_PER_SOL
+def get_sbt_level(tasks):
+    for i in range(len(SBT_THRESHOLDS)-1,-1,-1):
+        if tasks >= SBT_THRESHOLDS[i]: return i
+    return 0
+def get_sbt_label(level): return SBT_LEVELS.get(level, "Unknown")
+def days_left(deadline): return max(0, (deadline - int(time.time())) // 86400)
+def short_address(pk): return f"{pk[:4]}...{pk[-4:]}"
+def explorer_url(val, type_="address", cluster="devnet"):
+    cp = f"?cluster={cluster}" if cluster != "mainnet-beta" else ""
+    return f"https://explorer.solana.com/{type_}/{val}{cp}"

nexum_sdk-0.1.0/nexum_sdk.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: nexum-sdk
+Version: 0.1.0
+Summary: Official Python SDK for NEXUM Protocol on Solana
+Author-email: NEXUM Protocol <protocolnexum@gmail.com>
+License: MIT
+Project-URL: Homepage, https://nexum-protocol.netlify.app
+Project-URL: Repository, https://github.com/Nexumprotocol/nexum-sdk
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: base58>=2.1.1
+Requires-Dist: solders>=0.21.0

nexum_sdk-0.1.0/nexum_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+nexum_sdk/__init__.py
+nexum_sdk/client.py
+nexum_sdk/constants.py
+nexum_sdk/types.py
+nexum_sdk/utils.py
+nexum_sdk.egg-info/PKG-INFO
+nexum_sdk.egg-info/SOURCES.txt
+nexum_sdk.egg-info/dependency_links.txt
+nexum_sdk.egg-info/requires.txt
+nexum_sdk.egg-info/top_level.txt

nexum_sdk-0.1.0/nexum_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nexum_sdk-0.1.0/nexum_sdk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx>=0.27.0
+base58>=2.1.1
+solders>=0.21.0

nexum_sdk-0.1.0/nexum_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+nexum_sdk

nexum_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nexum-sdk"
+version = "0.1.0"
+description = "Official Python SDK for NEXUM Protocol on Solana"
+license = {text = "MIT"}
+authors = [{name = "NEXUM Protocol", email = "protocolnexum@gmail.com"}]
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.27.0", "base58>=2.1.1", "solders>=0.21.0"]
+
+[project.urls]
+Homepage = "https://nexum-protocol.netlify.app"
+Repository = "https://github.com/Nexumprotocol/nexum-sdk"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["nexum_sdk*"]

nexum_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+