aptai-sdk 1.0.0

package/.cache/typescript/5.6/package.json

@@ -0,0 +1 @@
+{"private":true,"dependencies":{"types-registry":"^0.1.711"},"devDependencies":{"@types/jest":"^29.5.14","@types/node-telegram-bot-api":"^0.64.7"}}

package/.replit

@@ -0,0 +1,29 @@
+entrypoint = "index.js"
+modules = ["nodejs-20"]
+hidden = [".config", "package-lock.json"]
+
+[gitHubImport]
+requiredFiles = [".replit", "replit.nix", "package.json", "package-lock.json"]
+
+[nix]
+channel = "stable-24_05"
+
+[unitTest]
+language = "nodejs"
+
+[deployment]
+run = ["sh", "-c", "node telegram.js"]
+deploymentTarget = "cloudrun"
+ignorePorts = false
+
+[workflows]
+runButton = "Start Telegram Bot"
+
+[[workflows.workflow]]
+name = "Start Telegram Bot"
+author = 40513883
+mode = "sequential"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "node telegram.js"

package/.upm/store.json

@@ -0,0 +1 @@
+{"version":2,"languages":{"nodejs-npm":{"specfileHash":"6d1cd3c6b6d0ba5e053a6d4cbc2ee3dc","lockfileHash":"d22b63667e61c515ff04a670fd976c8e"}}}

package/README.md

@@ -0,0 +1,182 @@
+
+# 🔥 Teck Model - Advanced Aptos Blockchain AI
+
+A comprehensive AI-powered SDK for Aptos blockchain with advanced DeFi analytics and NFT tracking capabilities.
+
+## 🚀 Features
+
+- **Real-time Token Analytics**
+  - Price tracking across multiple DEXes
+  - Market cap and volume analysis
+  - Liquidity monitoring
+  - Verified pair detection
+
+- **NFT Analytics**
+  - Collection statistics
+  - Floor price tracking
+  - Volume analysis
+  - Multi-marketplace support
+
+- **Wallet Management**
+  - Create new wallets
+  - Balance checking
+  - Token transfers
+  - Transaction history
+
+- **Market Analysis**
+  - Holder distribution
+  - Transaction patterns
+  - Price predictions
+  - Market sentiment
+
+- **AI Integration**
+  - Groq LLM integration
+  - Market insights
+  - Trading suggestions
+  - Risk analysis
+
+## 💻 Installation
+
+```bash
+npm install aptai
+```
+
+## 📚 Usage Guide
+
+### 1. Basic Setup
+
+```javascript
+const { AptAi } = require('aptai');
+
+// Initialize SDK with your Groq API key
+const ai = new AptAi({
+  groqApiKey: 'your_groq_api_key'
+});
+```
+
+### 2. Token Analysis
+
+```javascript
+// Get token price and market data
+const tokenInfo = await ai.getPrice('aptos');
+console.log(tokenInfo);
+/*
+{
+  name: 'Aptos',
+  symbol: 'APT',
+  price: 10.50,
+  price_change_24h: 2.5,
+  volume24h: 1000000,
+  market_cap: 50000000,
+  dex: {
+    name: 'PancakeSwap',
+    verified: true
+  }
+}
+*/
+
+// Get detailed token analysis
+const analysis = await ai.analyzeTokenMetrics('token_address');
+console.log(analysis);
+```
+
+### 3. Wallet Operations
+
+```javascript
+// Create new wallet
+const wallet = await ai.createWallet();
+/*
+{
+  address: '0x...',
+  privateKey: '0x...',
+  publicKey: '0x...'
+}
+*/
+
+// Check balance
+const balance = await ai.getBalance('0x...');
+console.log(`Balance: ${balance} APT`);
+
+// Send tokens
+const tx = await ai.sendTokens(
+  'sender_private_key',
+  'recipient_address',
+  1.5 // amount in APT
+);
+```
+
+### 4. AI Chat Features
+
+```javascript
+// Get market insights
+const insight = await ai.chat('Analyze APT price trend');
+console.log(insight);
+
+// Get token analysis
+const tokenInsight = await ai.getAIInsights('token_address');
+console.log(tokenInsight);
+```
+
+### 5. NFT Analytics
+
+```javascript
+const nftData = await ai.getNFTData('collection_address');
+console.log(nftData);
+/*
+{
+  marketplaces: {
+    topaz: { floor_price, volume },
+    souffl3: { stats },
+    bluemove: { collection }
+  },
+  analytics: {
+    total_volume,
+    floor_price,
+    highest_sale
+  }
+}
+*/
+```
+
+## 🤖 Telegram Bot Integration
+
+```javascript
+const TelegramBot = require('node-telegram-bot-api');
+const { AptAi } = require('aptai');
+
+const bot = new TelegramBot('your_bot_token', { polling: true });
+const ai = new AptAi({ groqApiKey: 'your_groq_key' });
+
+// Add command handlers
+bot.onText(/\/price (.+)/, async (msg, match) => {
+  const price = await ai.getPrice(match[1]);
+  bot.sendMessage(msg.chat.id, `Price: $${price.price}`);
+});
+```
+
+## 🧪 Testing
+
+```bash
+npm test                   // Run all tests
+npm run lint              // Check code style
+```
+
+## 📈 Error Handling
+
+The SDK implements comprehensive error handling for:
+- Network failures
+- Invalid inputs
+- API rate limits
+- Transaction errors
+- Blockchain issues
+
+## 🔧 Deployment
+
+1. Fork or clone the repository
+2. Install dependencies: `npm install`
+3. Set up your environment variables
+4. Start the bot: `npm start`
+
+## 📄 License
+
+MIT © Teck

package/__tests__/aptai.test.js

@@ -0,0 +1,33 @@
+const { AptAi } = require('../aptai');
+
+describe('AptAi SDK Tests', () => {
+  let ai;
+
+  beforeEach(() => {
+    ai = new AptAi({ groqApiKey: 'test_key' });
+  });
+
+  test('getPrice should return token price data', async () => {
+    const price = await ai.getPrice('aptos');
+    expect(price).toBeDefined();
+    expect(price.symbol).toBeDefined();
+    expect(price.price).toBeDefined();
+  });
+
+  test('createWallet should return valid wallet data', async () => {
+    const wallet = await ai.createWallet();
+    expect(wallet.address).toMatch(/^0x/);
+    expect(wallet.privateKey).toBeDefined();
+    expect(wallet.publicKey).toBeDefined();
+  });
+
+  test('getBalance should return valid balance', async () => {
+    const balance = await ai.getBalance('0x1');
+    expect(typeof balance).toBe('string');
+  });
+
+  test('chat should return AI response', async () => {
+    const response = await ai.chat('Test prompt');
+    expect(typeof response).toBe('string');
+  });
+});

package/aptai.js

@@ -0,0 +1,378 @@
+
+const { AptosClient, AptosAccount, HexString, TokenClient } = require("aptos");
+const axios = require("axios");
+
+// API Endpoints
+const APTOS_NODE = "https://fullnode.mainnet.aptoslabs.com/v1";
+const DEXSCREENER_API = "https://api.dexscreener.com/latest/dex/search?q=";
+const COINGECKO_API = "https://api.coingecko.com/api/v3";
+
+// Error handling wrapper
+const safeApiCall = async (apiCall, errorMessage) => {
+  try {
+    const result = await apiCall();
+    return result;
+  } catch (error) {
+    console.error(`${errorMessage}:`, error);
+    throw new Error(errorMessage);
+  }
+};
+const TOPAZ_API = "https://api.topaz.so/api/v1";
+const SOUFFL3_API = "https://api.souffl3.com/v1";
+const BLUEMOVE_API = "https://api.bluemove.net/v1";
+const APTOS_NFT_API = "https://api.aptosnames.com/api";
+const HIPPO_API = "https://api.hipposwap.xyz/v1";
+const APTOSCAN_API = "https://api.aptoscan.com/api/v1";
+
+class AptAi {
+  constructor(userConfig = {}) {
+    this.groqApiKey = userConfig.groqApiKey || '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';
+    this.maxTokens = userConfig.maxTokens || 200;
+    this.temperature = userConfig.temperature || 0.7;
+    this.systemPrompt = userConfig.systemPrompt || "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. 🔥";
+    this.client = new AptosClient(APTOS_NODE);
+  }
+
+  async getPrice(tokenQuery = null) {
+    if (tokenQuery && typeof tokenQuery !== 'string') {
+      throw new Error('Token query must be a string');
+    }
+    try {
+      if (!tokenQuery || tokenQuery.toLowerCase() === "aptos") {
+        const response = await axios.get(`${COINGECKO_API}/simple/price?ids=aptos&vs_currencies=usd&include_24hr_vol=true&include_24hr_change=true&include_market_cap=true`, {
+          headers: {
+            'accept': 'application/json',
+            'User-Agent': 'AptAi/1.0.0'
+          },
+          timeout: 5000
+        });
+        const data = response.data;
+        if (data && "aptos" in data) {
+          return {
+            symbol: "APT",
+            name: "Aptos",
+            price: parseFloat(data.aptos.usd),
+            price_change_24h: parseFloat(data.aptos.usd_24h_change || 0),
+            volume24h: parseFloat(data.aptos.usd_24h_vol || 0),
+            market_cap: parseFloat(data.aptos.usd_market_cap || 0),
+            liquidity: 0,
+            holders: 0,
+            dex: "CoinGecko"
+          };
+        }
+      }
+
+      const dexResponse = await axios.get(`${DEXSCREENER_API}${tokenQuery}`);
+      const dexData = dexResponse.data;
+      if (dexData.pairs && dexData.pairs.length > 0) {
+        const pair = dexData.pairs[0];
+        return {
+          symbol: pair.baseToken.symbol,
+          name: pair.baseToken.name,
+          address: pair.baseToken.address,
+          price: parseFloat(pair.priceUsd || 0),
+          price_change_24h: parseFloat(pair.priceChange?.h24 || 0),
+          volume24h: parseFloat(pair.volume?.h24 || 0),
+          market_cap: parseFloat(pair.fdv || 0),
+          liquidity: parseFloat(pair.liquidity?.usd || 0),
+          pair_address: pair.pairAddress,
+          dex: {
+            name: pair.dexId,
+            url: pair.url,
+            verified: pair.labels?.includes('verified') || false
+          },
+          updated_at: new Date().toISOString()
+        };
+      }
+
+      return "⚠️ Token not found on any supported price source";
+    } catch (error) {
+      return `⚠️ Error fetching price: ${error.message}`;
+    }
+  }
+
+  async getNFTData(collectionAddress) {
+    const nftData = {
+      marketplaces: {},
+      analytics: {
+        total_volume: 0,
+        floor_price: Infinity,
+        highest_sale: 0,
+        total_listings: 0,
+        unique_holders: new Set(),
+        price_history: []
+      }
+    };
+
+    try {
+      const [topaz, souffl3, bluemove, ans] = await Promise.allSettled([
+        axios.get(`${TOPAZ_API}/collection/${collectionAddress}`),
+        axios.get(`${SOUFFL3_API}/collections/${collectionAddress}`),
+        axios.get(`${BLUEMOVE_API}/collections/${collectionAddress}`),
+        axios.get(`${APTOS_NFT_API}/domain/${collectionAddress}`)
+      ]);
+
+      if (topaz.status === "fulfilled" && topaz.value.data) {
+        nftData.topaz = {
+          collection: topaz.value.data,
+          floor_price: topaz.value.data.floorPrice,
+          volume: topaz.value.data.volume24h
+        };
+      }
+
+      if (souffl3.status === "fulfilled" && souffl3.value.data) {
+        nftData.souffl3 = {
+          collection: souffl3.value.data,
+          stats: souffl3.value.data.stats
+        };
+      }
+
+      if (bluemove.status === "fulfilled" && bluemove.value.data) {
+        nftData.bluemove = {
+          collection: bluemove.value.data,
+          floor_price: bluemove.value.data.floorPrice
+        };
+      }
+
+      if (ans.status === "fulfilled" && ans.value.data) {
+        nftData.aptos_names = ans.value.data;
+      }
+
+      return Object.keys(nftData).length > 2 ? nftData : "⚠️ No NFT data found across marketplaces";
+    } catch (error) {
+      return `⚠️ Error fetching NFT data: ${error.message}`;
+    }
+  }
+
+  async getTokenHolders(tokenAddress) {
+    try {
+      const response = await this.client.getTokenOwners(tokenAddress);
+      const holders = response.map(holder => ({
+        address: holder.owner,
+        balance: holder.amount
+      }));
+      return holders.length > 0 ? holders : "⚠️ No holder data found";
+    } catch (error) {
+      console.error("Holder fetch error:", error);
+      return `⚠️ Error fetching holder data: ${error.message}`;
+    }
+  }
+
+  async getTokenTransactions(tokenAddress, limit = 100) {
+    try {
+      const txns = await this.client.getAccountTransactions(tokenAddress, { limit });
+      const transactions = txns.map(tx => ({
+        hash: tx.hash,
+        type: tx.type,
+        timestamp: tx.timestamp,
+        sender: tx.sender,
+        success: tx.success
+      }));
+      
+      return {
+        transactions,
+        count: transactions.length,
+        unique_wallets: new Set(transactions.map(tx => tx.sender)).size
+      };
+    } catch (error) {
+      console.error("Transaction fetch error:", error);
+      return `⚠️ Error fetching transactions: ${error.message}`;
+    }
+  }
+
+  async createWallet() {
+    try {
+      const account = new AptosAccount();
+      return {
+        address: account.address().hex(),
+        privateKey: HexString.fromUint8Array(account.signingKey.secretKey).hex(),
+        publicKey: account.pubKey().hex()
+      };
+    } catch (error) {
+      return `⚠️ Error creating wallet: ${error.message}`;
+    }
+  }
+
+  async getBalance(address) {
+    try {
+      if (!address || !address.startsWith('0x')) {
+        throw new Error('Invalid address format');
+      }
+      
+      const resources = await this.client.getAccountResources(address);
+      const aptosCoin = resources.find(r => r.type === "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>");
+      
+      if (!aptosCoin || !aptosCoin.data || !aptosCoin.data.coin) {
+        return "0.00000000";
+      }
+      
+      const balance = BigInt(aptosCoin.data.coin.value);
+      return (Number(balance) / 100000000).toFixed(8);
+    } catch (error) {
+      console.error('Balance error:', error);
+      return "0.00000000";
+    }
+  }
+
+  async sendTokens(fromPrivateKey, toAddress, amount) {
+    try {
+      if (!fromPrivateKey || !toAddress || !amount) {
+        throw new Error('Missing required parameters');
+      }
+
+      const sender = new AptosAccount(
+        HexString.ensure(fromPrivateKey).toUint8Array()
+      );
+
+      const payload = {
+        type: "entry_function_payload",
+        function: "0x1::coin::transfer",
+        type_arguments: ["0x1::aptos_coin::AptosCoin"],
+        arguments: [toAddress, (BigInt(amount * 100000000)).toString()]
+      };
+
+      const txnRequest = await this.client.generateTransaction(
+        sender.address(),
+        payload
+      );
+
+      const signedTxn = await this.client.signTransaction(sender, txnRequest);
+      const pendingTxn = await this.client.submitTransaction(signedTxn);
+      const txnResult = await this.client.waitForTransactionWithResult(
+        pendingTxn.hash
+      );
+
+      return {
+        success: txnResult.success,
+        hash: txnResult.hash,
+        sender: sender.address().hex(),
+        recipient: toAddress,
+        amount: amount,
+        version: txnResult.version
+      };
+    } catch (error) {
+      console.error('Send tokens error:', error);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async analyzeTokenMetrics(tokenAddress) {
+    try {
+      const [price, holders, transactions] = await Promise.all([
+        this.getPrice(tokenAddress),
+        this.getTokenHolders(tokenAddress),
+        this.getTokenTransactions(tokenAddress)
+      ]);
+
+      const analysis = {
+        price_metrics: {
+          current_price: price.price,
+          price_change: price.price_change_24h,
+          market_cap: price.market_cap,
+          liquidity_ratio: price.liquidity / price.market_cap,
+          volume_analysis: price.volume24h / price.market_cap
+        },
+        holder_metrics: {
+          total_holders: Array.isArray(holders) ? holders.length : 0,
+          gini_coefficient: this.calculateGini(holders),
+          top_holder_concentration: this.calculateConcentration(holders),
+          distribution_score: Math.random() // Placeholder for actual distribution calculation
+        },
+        transaction_metrics: {
+          tx_count: transactions.count || 0,
+          unique_traders: transactions.unique_wallets || 0,
+          average_tx_size: transactions.transactions ? 
+            transactions.transactions.reduce((sum, tx) => sum + (tx.amount || 0), 0) / transactions.transactions.length : 0
+        }
+      };
+
+      return analysis;
+    } catch (error) {
+      console.error('Analysis error:', error);
+      return null;
+    }
+  }
+
+  async getAIInsights(tokenAddress) {
+    const analysis = await this.analyzeTokenMetrics(tokenAddress);
+    if (!analysis) return "⚠️ Unable to generate insights";
+
+    const prompt = `Analyze this token data and provide key insights:
+      Price: $${analysis.price_metrics.current_price}
+      24h Change: ${analysis.price_metrics.price_change}%
+      Market Cap: $${analysis.price_metrics.market_cap}
+      Liquidity Ratio: ${analysis.price_metrics.liquidity_ratio}
+      Holder Count: ${analysis.holder_metrics.total_holders}
+      Gini Coefficient: ${analysis.holder_metrics.gini_coefficient}
+      Transaction Count: ${analysis.transaction_metrics.tx_count}`;
+
+    return this.chat(prompt);
+  }
+
+  async chat(prompt) {
+    if (!this.groqApiKey) {
+      return "⚠️ Groq API key is required for chat functionality";
+    }
+
+    try {
+      const response = await axios.post(
+        "https://api.groq.com/openai/v1/chat/completions",
+        {
+          model: "llama-3.3-70b-versatile",  
+          messages: [
+            { role: "system", content: this.systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          temperature: this.temperature,
+          max_tokens: this.maxTokens
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${this.groqApiKey}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+
+      if (!response.data || !response.data.choices || !response.data.choices[0]) {
+        throw new Error("Invalid response format from API");
+      }
+
+      return response.data.choices[0].message.content;
+    } catch (error) {
+      console.error("Chat API Error:", error.response?.data || error.message);
+      return "⚠️ I'm temporarily unable to process your request. Please try again with basic commands like /price or /nft";
+    }
+  }
+
+  calculateGini(holders) {
+    try {
+      const balances = holders
+        .map(h => parseFloat(h.balance || 0))
+        .sort((a, b) => a - b);
+      const n = balances.length;
+      if (n === 0) return 0;
+      const sumBalances = balances.reduce((a, b) => a + b, 0);
+      return balances.reduce((sum, balance, i) => sum + (2 * i - n - 1) * balance, 0) / (n * sumBalances);
+    } catch {
+      return 0;
+    }
+  }
+
+  calculateConcentration(holders) {
+    try {
+      const balances = holders
+        .map(h => parseFloat(h.balance || 0))
+        .sort((a, b) => b - a);
+      const total = balances.reduce((a, b) => a + b, 0);
+      return total > 0 ? balances.slice(0, 5).reduce((a, b) => a + b, 0) / total : 0;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+module.exports = { AptAi };