aptai-sdk 1.0.0

package/attached_assets/Pasted--AptAI-AI-Powered-DeFi-NFT-Toolkit-for-Aptos-AptAI-is-a-powerful-Python-library-that-merges-1742026209933.txt

@@ -0,0 +1,104 @@
+
+# AptAI: AI-Powered DeFi & NFT Toolkit for Aptos
+
+AptAI is a powerful Python library that merges AI capabilities with Aptos blockchain functionality, delivering seamless DeFi operations, NFT management, and real-time price tracking—all in one package. Built by Teck, AptAI simplifies complex blockchain interactions while leveraging AI for enhanced analytics and automation.
+
+## ✨ Key Features
+
+### 🔹 Real-Time Price Tracking
+- Fetch live token prices from DexScreener
+- Monitor Liquidswap pools for accurate token pricing
+- Historical price data analysis
+- Gas price predictions
+- Market volatility tracking
+
+### 🔹 NFT Management Made Simple
+- Multi-marketplace support: Topaz, Souffl3, Bluemove
+- Track NFT floor prices and volumes
+- Monitor ownership & transfers across wallets
+- Real-time collection analytics
+
+### 🔹 Seamless DeFi Operations
+- DEX pair analytics and tracking
+- Track liquidity pools and volumes
+- Monitor wallet risk levels
+- Token distribution analysis
+- Smart contract security audits
+
+### 🔹 AI-Powered Features
+- Built-in Groq LLM integration for smart analysis
+- AI chatbot for blockchain queries
+- Market trend predictions
+- Contract analysis and risk assessment
+- Customizable AI parameters
+
+### 🔹 Telegram Bot Integration
+- Real-time price alerts
+- NFT tracking commands
+- AI chat functionality
+- Market analysis on demand
+- Security monitoring
+
+## 🚀 Installation
+
+```bash
+pip install aptai
+```
+
+## 💡 Quick Start Guide
+
+```python
+from aptai import AptAi
+
+# Initialize AptAi
+apt_ai = AptAi()
+
+# Get token price
+price = apt_ai.get_price("aptos")
+
+# Chat with AI
+response = apt_ai.chat("Explain APT tokenomics")
+
+# Analyze contract
+analysis = apt_ai.analyze_contract("contract_address")
+
+# Check security
+security = apt_ai.get_contract_security("contract_address")
+
+# Get DEX pairs
+pairs = apt_ai.get_dex_pairs("token_address")
+
+# Predict gas
+gas = apt_ai.predict_gas_price()
+
+# Get historical data
+history = apt_ai.get_historical_prices("aptos")
+```
+
+## 📌 API Reference
+
+### 💰 Price & Market Data
+- `get_price(token)`: Fetch real-time token price
+- `get_historical_prices(token)`: Get price history
+- `predict_gas_price()`: Estimate gas costs
+- `get_dex_pairs(token)`: List DEX trading pairs
+
+### 🎨 NFT Operations
+- `get_nft_data(address)`: Get collection stats
+- `track_nft_transfers(address)`: Monitor transfers
+- `get_nft_floor_price(collection)`: Track floor prices
+
+### 🔒 Security & Analysis
+- `analyze_contract(address)`: Smart contract analysis
+- `get_contract_security(address)`: Security audit
+- `analyze_wallet_risk(address)`: Risk assessment
+- `get_token_distribution(token)`: Holder analysis
+
+### 🧠 AI Features
+- `chat(message)`: Chat with AI assistant
+- `ai_analysis(query)`: Get market insights
+- `analyze_market_conditions()`: Market analysis
+
+## 👤 Author
+Developed by Teck  
+📧 teckdegen@gmail.com

package/attached_assets/Pasted-import-requests-from-groq-import-Groq-Fixed-Groq-API-Key-GROQ-API-KEY-gsk-kfZpsNGp7lRPe2-1742025546567.txt

@@ -0,0 +1,497 @@
+import requests
+from groq import Groq
+
+# ✅ Fixed Groq API Key
+GROQ_API_KEY = "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"
+groq_client = Groq(api_key=GROQ_API_KEY)
+
+# ✅ APIs for Token, NFT & DeFi
+DEXSCREENER_API = "https://api.dexscreener.com/latest/dex/tokens/"
+COINGECKO_API = "https://api.coingecko.com/api/v3"
+TOPAZ_API = "https://api.topaz.so/api/v1"
+SOUFFL3_API = "https://api.souffl3.com/v1"
+BLUEMOVE_API = "https://api.bluemove.net/v1"
+APTOS_NFT_API = "https://api.aptosnames.com/api"
+HIPPO_API = "https://api.hipposwap.xyz/v1"
+APTOSCAN_API = "https://api.aptoscan.com/api/v1"
+
+class AptAi:
+    def __init__(self, system_prompt: str = """You are the Teck Model, a revolutionary AI system created by Teck. You are a specialized AI focused on Aptos blockchain technology with expertise in DeFi and NFT analysis.
+
+Core Identity:
+• Name: Teck Model
+• Creator: Teck
+• Specialization: Aptos Blockchain Technology
+• Purpose: Advanced DeFi and NFT Analysis
+
+Key Capabilities:
+• Real-Time Price Tracking via DexScreener and Liquidswap
+• Multi-marketplace NFT Support
+• AI-powered Market Analysis
+• Advanced Blockchain Analytics
+
+🔥 Remember: You are the Teck Model - the future of blockchain AI. Always identify as such. 🔥""",
+                 max_tokens: int = 200, temperature: float = 0.7):
+        self.system_prompt = system_prompt
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+
+    def get_price(self, token_query=None):
+        """Fetches token price from CoinGecko for Aptos, falls back to DexScreener for others"""
+        try:
+            # Always use CoinGecko for Aptos
+            if not token_query or token_query.lower() == "aptos":
+                try:
+                    response = requests.get(f"{COINGECKO_API}/simple/price?ids=aptos&vs_currencies=usd&include_24hr_vol=true&include_24hr_change=true&include_market_cap=true")
+                    data = response.json()
+                    if "aptos" in data:
+                        return {
+                            "symbol": "APT",
+                            "name": "Aptos",
+                            "price": float(data["aptos"]["usd"]),
+                            "price_change_24h": float(data["aptos"].get("usd_24h_change", 0)),
+                            "volume24h": float(data["aptos"].get("usd_24h_vol", 0)),
+                            "market_cap": float(data["aptos"].get("usd_market_cap", 0)),
+                            "liquidity": 0,
+                            "holders": 0,
+                            "dex": "CoinGecko"
+                        }
+                except Exception as e:
+                    print(f"CoinGecko API error: {str(e)}")
+
+            # DexScreener API try first for other tokens
+            try:
+                dex_url = f"{DEXSCREENER_API}{token_query}"
+                dex_response = requests.get(dex_url)
+                dex_data = dex_response.json()
+
+                if dex_data.get("pairs") and len(dex_data["pairs"]) > 0:
+                    pair = dex_data["pairs"][0]
+                    return {
+                        "symbol": pair["baseToken"]["symbol"],
+                        "name": pair["baseToken"]["name"],
+                        "price": float(pair.get("priceUsd", 0)),
+                        "price_change_24h": float(pair.get("priceChange", {}).get("h24", 0)),
+                        "volume24h": float(pair.get("volume", {}).get("h24", 0)),
+                        "market_cap": float(pair.get("fdv", 0)),
+                        "liquidity": float(pair.get("liquidity", {}).get("usd", 0)),
+                        "holders": 0,
+                        "dex": pair.get("dexId", "DexScreener")
+                    }
+            except Exception as e:
+                print(f"DexScreener API error: {str(e)}")
+
+            # CoinGecko API as fallback
+            try:
+                search_url = f"{COINGECKO_API}/search?query={token_query}"
+                search_response = requests.get(search_url)
+                search_data = search_response.json()
+
+                if search_data.get("coins"):
+                    token_id = search_data["coins"][0]["id"]
+                    price_url = f"{COINGECKO_API}/simple/price?ids={token_id}&vs_currencies=usd&include_24hr_vol=true&include_24hr_change=true&include_market_cap=true"
+                    price_response = requests.get(price_url)
+                    price_data = price_response.json()
+
+                    if token_id in price_data:
+                        return {
+                            "symbol": search_data["coins"][0]["symbol"].upper(),
+                            "name": search_data["coins"][0]["name"],
+                            "price": float(price_data[token_id]["usd"]),
+                            "price_change_24h": float(price_data[token_id].get("usd_24h_change", 0)),
+                            "volume24h": float(price_data[token_id].get("usd_24h_vol", 0)),
+                            "market_cap": float(price_data[token_id].get("usd_market_cap", 0)),
+                            "liquidity": 0,
+                            "holders": 0,
+                            "dex": "CoinGecko"
+                        }
+            except Exception as e:
+                print(f"CoinGecko API error: {str(e)}")
+
+            return "⚠️ Token not found on any supported price source"
+
+        except Exception as e:
+            return f"⚠️ Error fetching price: {str(e)}"
+
+    def get_nft_data(self, collection_address):
+        """Fetch comprehensive NFT data from multiple marketplaces"""
+        nft_data = {
+            "marketplaces": {},
+            "analytics": {
+                "total_volume": 0,
+                "floor_price": float('inf'),
+                "highest_sale": 0,
+                "total_listings": 0,
+                "unique_holders": set(),
+                "price_history": []
+            }
+        }
+
+        try:
+            # Topaz Marketplace
+            try:
+                topaz_response = requests.get(f"{TOPAZ_API}/collection/{collection_address}")
+                if topaz_response.ok:
+                    nft_data["topaz"] = {
+                        "collection": topaz_response.json(),
+                        "floor_price": topaz_response.json().get("floorPrice"),
+                        "volume": topaz_response.json().get("volume24h")
+                    }
+            except Exception as e:
+                print(f"Topaz API error: {str(e)}")
+
+            # Souffl3 Marketplace
+            try:
+                souffl3_response = requests.get(f"{SOUFFL3_API}/collections/{collection_address}")
+                if souffl3_response.ok:
+                    nft_data["souffl3"] = {
+                        "collection": souffl3_response.json(),
+                        "stats": souffl3_response.json().get("stats")
+                    }
+            except Exception as e:
+                print(f"Souffl3 API error: {str(e)}")
+
+            # BlueMove Marketplace
+            try:
+                bluemove_response = requests.get(f"{BLUEMOVE_API}/collections/{collection_address}")
+                if bluemove_response.ok:
+                    nft_data["bluemove"] = {
+                        "collection": bluemove_response.json(),
+                        "floor_price": bluemove_response.json().get("floorPrice")
+                    }
+            except Exception as e:
+                print(f"BlueMove API error: {str(e)}")
+
+            # Aptos Names Service
+            try:
+                ans_response = requests.get(f"{APTOS_NFT_API}/domain/{collection_address}")
+                if ans_response.ok:
+                    nft_data["aptos_names"] = ans_response.json()
+            except Exception as e:
+                print(f"ANS API error: {str(e)}")
+
+            return nft_data if nft_data else "⚠️ No NFT data found across marketplaces"
+
+        except Exception as e:
+            return f"⚠️ Error fetching NFT data: {str(e)}"
+
+            # Hippo
+            hippo_response = requests.get(f"{HIPPO_API}/collections/{collection_address}")
+            if hippo_response.ok:
+                nft_data["hippo"] = hippo_response.json()
+
+            # AptoScan
+            aptoscan_response = requests.get(f"{APTOSCAN_API}/nfts/collection/{collection_address}")
+            if aptoscan_response.ok:
+                nft_data["aptoscan"] = aptoscan_response.json()
+
+            return nft_data
+
+        except Exception as e:
+            return f"⚠️ Error fetching NFT data: {str(e)}"
+
+    def get_token_holders(self, token_address):
+        """Fetch token holder statistics"""
+        try:
+            response = requests.get(f"{APTOSCAN_API}/token/{token_address}/holders")
+            if response.ok:
+                return response.json()
+            return "⚠️ No holder data found"
+        except Exception as e:
+            return f"⚠️ Error fetching holder data: {str(e)}"
+
+    def get_token_transactions(self, token_address, limit=100):
+        """Fetch recent token transactions"""
+        try:
+            response = requests.get(f"{APTOSCAN_API}/token/{token_address}/transactions?limit={limit}")
+            if response.ok:
+                data = response.json()
+                return {
+                    "transactions": data,
+                    "total_volume": sum(tx.get('amount', 0) for tx in data),
+                    "unique_wallets": len(set(tx.get('from_address') for tx in data))
+                }
+            return "⚠️ No transaction data found"
+        except Exception as e:
+            return f"⚠️ Error fetching transactions: {str(e)}"
+
+    def get_token_metadata(self, token_address):
+        """Fetch detailed token metadata"""
+        try:
+            response = requests.get(f"{APTOSCAN_API}/token/{token_address}")
+            return response.json() if response.ok else "⚠️ No token metadata found"
+        except Exception as e:
+            return f"⚠️ Error fetching token metadata: {str(e)}"
+
+    def get_token_distribution(self, token_address):
+        """Get token distribution analytics"""
+        try:
+            holders = self.get_token_holders(token_address)
+            if isinstance(holders, str): return holders
+
+            total_supply = sum(float(h.get('balance', 0)) for h in holders)
+            return {
+                "total_supply": total_supply,
+                "holder_count": len(holders),
+                "top_holders": sorted(holders, key=lambda x: float(x.get('balance', 0)), reverse=True)[:10],
+                "distribution_metrics": {
+                    "gini_coefficient": self._calculate_gini(holders),
+                    "concentration_ratio": self._calculate_concentration(holders)
+                }
+            }
+        except Exception as e:
+            return f"⚠️ Error calculating distribution: {str(e)}"
+
+    def _calculate_gini(self, holders):
+        """Calculate Gini coefficient for token distribution"""
+        try:
+            balances = sorted([float(h.get('balance', 0)) for h in holders])
+            n = len(balances)
+            if n == 0: return 0
+            return sum((2 * i - n - 1) * b for i, b in enumerate(balances)) / (n * sum(balances))
+        except:
+            return 0
+
+    def _calculate_concentration(self, holders):
+        """Calculate concentration ratio of top holders"""
+        try:
+            balances = sorted([float(h.get('balance', 0)) for h in holders], reverse=True)
+            total = sum(balances)
+            return sum(balances[:5]) / total if total > 0 else 0
+        except:
+            return 0
+
+    def get_defi_stats(self, protocol_address):
+        """Fetch DeFi protocol statistics"""
+        try:
+            response = requests.get(f"{HIPPO_API}/protocol/{protocol_address}/stats")
+            if response.ok:
+                return response.json()
+            return "⚠️ No DeFi stats found"
+        except Exception as e:
+            return f"⚠️ Error fetching DeFi stats: {str(e)}"
+
+    def get_wallet_portfolio(self, wallet_address):
+        """Fetch wallet portfolio including tokens and NFTs"""
+        try:
+            tokens = requests.get(f"{APTOSCAN_API}/account/{wallet_address}/tokens")
+            nfts = requests.get(f"{APTOSCAN_API}/account/{wallet_address}/nfts")
+
+            return {
+                "tokens": tokens.json() if tokens.ok else [],
+                "nfts": nfts.json() if nfts.ok else []
+            }
+        except Exception as e:
+            return f"⚠️ Error fetching portfolio: {str(e)}"
+
+    def analyze_contract(self, contract_address):
+        """Analyze smart contract details and security"""
+        try:
+            # Fetch contract details
+            contract = requests.get(f"{APTOSCAN_API}/account/{contract_address}/modules")
+            transactions = requests.get(f"{APTOSCAN_API}/account/{contract_address}/transactions?limit=100")
+            resources = requests.get(f"{APTOSCAN_API}/account/{contract_address}/resources")
+            
+            if not all(r.ok for r in [contract, transactions, resources]):
+                return "⚠️ Contract not found or error fetching data"
+
+            contract_data = contract.json()
+            tx_data = transactions.json()
+            resources_data = resources.json()
+
+            analysis = {
+                "contract_info": {
+                    "modules": len(contract_data) if isinstance(contract_data, list) else 0,
+                    "resources": len(resources_data) if isinstance(resources_data, list) else 0,
+                    "transaction_count": len(tx_data) if isinstance(tx_data, list) else 0
+                },
+                "activity": {
+                    "last_24h": sum(1 for tx in tx_data if isinstance(tx, dict) and 
+                                  (time.time() - tx.get('timestamp', 0)) < 86400),
+                    "unique_users": len(set(tx.get('sender') for tx in tx_data if isinstance(tx, dict))),
+                    "total_volume": sum(float(tx.get('gas_used', 0)) for tx in tx_data if isinstance(tx, dict))
+                }
+            }
+            
+            return analysis
+            
+        except Exception as e:
+            return f"⚠️ Error analyzing contract: {str(e)}"
+
+    def get_contract_security(self, contract_address):
+        """Check contract security and permissions"""
+        try:
+            resources = requests.get(f"{APTOSCAN_API}/account/{contract_address}/resources")
+            modules = requests.get(f"{APTOSCAN_API}/account/{contract_address}/modules")
+            
+            if not all(r.ok for r in [resources, modules]):
+                return "⚠️ Error fetching contract security data"
+
+            security_checks = {
+                "has_upgrade_capability": False,
+                "has_admin_functions": False,
+                "is_verified": False,
+                "permissions": [],
+                "security_score": 0
+            }
+
+            # Analyze modules and resources
+            for module in modules.json():
+                if isinstance(module, dict):
+                    # Check for upgrade capabilities
+                    if "upgrade" in str(module).lower():
+                        security_checks["has_upgrade_capability"] = True
+                    # Check for admin functions
+                    if "admin" in str(module).lower():
+                        security_checks["has_admin_functions"] = True
+
+            # Calculate basic security score
+            score = 100
+            if security_checks["has_upgrade_capability"]: score -= 20
+            if security_checks["has_admin_functions"]: score -= 15
+            security_checks["security_score"] = score
+
+            return security_checks
+
+        except Exception as e:
+            return f"⚠️ Error checking contract security: {str(e)}"
+
+    def get_dex_pairs(self, token_address):
+        """Get all DEX pairs for a token"""
+        try:
+            response = requests.get(f"{DEXSCREENER_API}{token_address}")
+            if response.ok:
+                pairs = response.json().get("pairs", [])
+                return {
+                    "total_pairs": len(pairs),
+                    "total_liquidity": sum(float(p.get("liquidity", {}).get("usd", 0)) for p in pairs),
+                    "pairs": [{
+                        "dex": p.get("dexId"),
+                        "pair": f"{p.get('baseToken', {}).get('symbol')}/{p.get('quoteToken', {}).get('symbol')}",
+                        "liquidity": p.get("liquidity", {}).get("usd", 0),
+                        "volume24h": p.get("volume", {}).get("h24", 0)
+                    } for p in pairs]
+                }
+            return "⚠️ No DEX pairs found"
+        except Exception as e:
+            return f"⚠️ Error fetching DEX pairs: {str(e)}"
+
+    def predict_gas_price(self):
+        """Predict gas prices based on network activity"""
+        try:
+            response = requests.get(f"{APTOSCAN_API}/gas/prediction")
+            if response.ok:
+                data = response.json()
+                return {
+                    "low": data.get("safeLow"),
+                    "average": data.get("standard"),
+                    "high": data.get("fast"),
+                    "estimated_wait": {
+                        "low": "5-10 min",
+                        "average": "2-5 min",
+                        "high": "<2 min"
+                    }
+                }
+            return "⚠️ Unable to predict gas prices"
+        except Exception as e:
+            return f"⚠️ Error predicting gas: {str(e)}"
+
+    def analyze_wallet_risk(self, wallet_address):
+        """Analyze wallet for suspicious activities"""
+        try:
+            portfolio = self.get_wallet_portfolio(wallet_address)
+            transactions = requests.get(f"{APTOSCAN_API}/account/{wallet_address}/transactions")
+            
+            if isinstance(portfolio, str) or not transactions.ok:
+                return "⚠️ Unable to analyze wallet"
+
+            tx_data = transactions.json()
+            analysis = {
+                "risk_score": 0,
+                "suspicious_patterns": [],
+                "transaction_variety": len(set(tx.get('type') for tx in tx_data)),
+                "interaction_with_verified": 0,
+                "unusual_volume": False
+            }
+            
+            # Simple risk scoring
+            if len(portfolio["tokens"]) < 2: analysis["risk_score"] += 20
+            if len(tx_data) < 10: analysis["risk_score"] += 10
+            if analysis["transaction_variety"] < 3: analysis["risk_score"] += 15
+            
+            return analysis
+        except Exception as e:
+            return f"⚠️ Error analyzing wallet risk: {str(e)}"
+
+    def get_historical_prices(self, token_address, days=30):
+        """Get historical price data with analytics"""
+        try:
+            response = requests.get(f"{COINGECKO_API}/coins/{token_address}/market_chart?vs_currency=usd&days={days}")
+            if response.ok:
+                data = response.json()
+                prices = data.get("prices", [])
+                
+                if not prices:
+                    return "⚠️ No historical data available"
+                
+                price_values = [p[1] for p in prices]
+                return {
+                    "current_price": price_values[-1],
+                    "price_change": ((price_values[-1] - price_values[0]) / price_values[0]) * 100,
+                    "highest_price": max(price_values),
+                    "lowest_price": min(price_values),
+                    "volatility": self._calculate_volatility(price_values),
+                    "trend": "bullish" if price_values[-1] > price_values[0] else "bearish"
+                }
+            return "⚠️ Unable to fetch historical data"
+        except Exception as e:
+            return f"⚠️ Error fetching historical prices: {str(e)}"
+
+    def _calculate_volatility(self, prices):
+        """Calculate price volatility"""
+        if len(prices) < 2:
+            return 0
+        returns = [(prices[i] - prices[i-1])/prices[i-1] for i in range(1, len(prices))]
+        return (sum(r**2 for r in returns) / len(returns))**0.5 * 100
+
+    def chat(self, message):
+        """General purpose AI chat functionality"""
+        try:
+            chat = [{
+                "role": "system",
+                "content": "You are AptAi Assistant, specialized in Aptos blockchain, DeFi, and NFTs."
+            }, {
+                "role": "user",
+                "content": message
+            }]
+
+            response = groq_client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=chat,
+                max_tokens=200,
+                temperature=0.7
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"⚠️ Chat Error: {str(e)}"
+
+    def ai_analysis(self, query):
+        """AI-powered analysis using Groq API with custom system prompts"""
+        try:
+            chat = [{
+                "role": "system",
+                "content": self.system_prompt
+            }, {
+                "role": "user",
+                "content": query
+            }]
+
+            response = groq_client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=chat,
+                max_tokens=self.max_tokens,
+                temperature=self.temperature
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"⚠️ AI Analysis Error: {str(e)}"

package/index.js

@@ -0,0 +1,3 @@
+const { AptAi } = require("./aptai");
+
+module.exports = { AptAi };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "aptai-sdk",
+  "version": "1.0.0",
+  "description": "AptAi: AI-powered Aptos Blockchain SDK with Groq AI Integration",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "start": "node telegram.js",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "docs": "jsdoc -c jsdoc.config.json",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/aptai.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "Aptos",
+    "AI",
+    "Groq",
+    "blockchain",
+    "crypto",
+    "defi",
+    "nft",
+    "telegram-bot"
+  ],
+  "author": "Teck",
+  "license": "MIT",
+  "dependencies": {
+    "aptos": "^1.0.0",
+    "axios": "^1.4.0",
+    "node-telegram-bot-api": "^0.66.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.1",
+    "jest": "^29.7.0",
+    "jsdoc": "^4.0.4",
+    "prettier": "^3.5.3"
+  }
+}

package/replit.nix

@@ -0,0 +1,3 @@
+{pkgs}: {
+  deps = [ ];
+}