npm install @mako/sdk
yarn add @mako/sdk

import { RealThreat } from '@realthreat/sdk';

const rt = new RealThreat({
    network: 'bsc',
    apiKey: 'YOUR_API_KEY'
});

// Connect wallet
await rt.wallet.connect();

// Analyze token
const analysis = await rt.analyzer.analyze('0x...');
console.log(analysis);

const analyzer = new RealThreat.Analyzer({
    bscscanKey: 'YOUR_BSCSCAN_KEY',
    openaiKey: 'YOUR_OPENAI_KEY'
});

// Analyze a token
const result = await analyzer.analyze('0x...');

// Access different data points
console.log(result.dexScreener); // Price, volume, liquidity
console.log(result.bscScan);     // Contract info, verification
console.log(result.aiAnalysis);  // AI sentiment & risk assessment

{
    "token": {
        "address": "0x...",
        "name": "Token Name",
        "symbol": "SYMBOL",
        "decimals": 18
    },
    "market": {
        "priceUSD": "0.00001234",
        "priceChange24h": "+15.67%",
        "volume24h": "1234567",
        "liquidity": "987654",
        "marketCap": "5000000",
        "fdv": "10000000"
    },
    "security": {
        "verified": true,
        "compiler": "v0.8.20+commit.a1b79de6",
        "holders": 1234
    },
    "ai": {
        "sentiment": "BULLISH",
        "riskLevel": "MEDIUM",
        "analysis": "Detailed AI analysis..."
    }
}

const builder = new RealThreat.Builder();

const tradingBot = await builder.create({
    type: 'trading-bot',
    name: 'Smart Momentum Trader',
    chain: 'bsc',
    strategy: {
        type: 'momentum',
        indicators: ['RSI', 'MACD', 'Volume'],
        riskLevel: 'medium'
    }
});

// Generated code includes:
// - Smart contract for automated trading
// - Frontend interface
// - Backend API
// - Testing suite
// - Deployment scripts

await tradingBot.deploy();

const customApp = await builder.generate({
    description: 'Create a yield farming aggregator that automatically compounds rewards across multiple protocols',
    features: [
        'Multi-protocol support',
        'Auto-compounding',
        'Gas optimization',
        'Emergency withdrawal'
    ],
    chain: 'bsc'
});

// AI generates complete application
console.log(customApp.contracts);  // Solidity smart contracts
console.log(customApp.frontend);   // React frontend
console.log(customApp.backend);    // Node.js API

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract RealThreatToken is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 1000000000 * 10**18;
    
    constructor() ERC20("RealThreat", "RTH") {
        _mint(msg.sender, MAX_SUPPLY);
    }
    
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

pragma solidity ^0.8.20;

contract RealThreatStaking {
    IERC20 public stakingToken;
    IERC20 public rewardToken;
    
    uint256 public rewardRate = 100;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;
    mapping(address => uint256) public balances;
    
    function stake(uint256 amount) external {
        updateReward(msg.sender);
        balances[msg.sender] += amount;
        stakingToken.transferFrom(msg.sender, address(this), amount);
    }
    
    function withdraw(uint256 amount) external {
        updateReward(msg.sender);
        balances[msg.sender] -= amount;
        stakingToken.transfer(msg.sender, amount);
    }
    
    functio getReward() external {
        updateReward(msg.sender);
        uint256 reward = rewards[msg.sender];
        rewards[msg.sender] = 0;
        rewardToken.transfer(msg.sender, reward);
    }
}

const fetchDexScreener = async (tokenAddress) => {
    const response = await fetch(
        `https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`
    );
    const data = await response.json();
    
    if (data.pairs && data.pairs.length > 0) {
        const bscPair = data.pairs.find(p => p.chainId === 'bsc');
        return {
            price: bscPair.priceUsd,
            volume24h: bscPair.volume.h24,
            liquidity: bscPair.liquidity.usd,
            priceChange24h: bscPair.priceChange.h24
        };
    }
};

const fetchBSCScan = async (address, apiKey) => {
    const endpoints = {
        tokenInfo: `https://api.bscscan.com/api?module=token&action=tokeninfo&contractaddress=${address}&apikey=${apiKey}`,
        contract: `https://api.bscscan.com/api?module=contract&action=getsourcecode&address=${address}&apikey=${apiKey}`
    };
    
    const [tokenData, contractData] = await Promise.all([
        fetch(endpoints.tokenInfo),
        fetch(endpoints.contract)
    ]);
    
    return {
        token: await tokenData.json(),
        contract: await contractData.json()
    };
};

const analyzeWithAI = async (tokenData, apiKey) => {
    const response = await fetch('https://api.openai.com/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`
        },
        body: JSON.stringify({
            model: 'gpt-4',
            messages: [{
                role: 'system',
                content: 'You are a professional DeFi analyst.'
            }, {
                role: 'user',
                content: `Analyze this token: ${JSON.stringify(tokenData)}`
            }]
        })
    });
    
    const analysis = await response.json();
    return analysis.choices[0].message.content;
};

import { RealThreat, Strategy } from '@realthreat/sdk';

class MomentumTradingBot extends Strategy {
    constructor(config) {
        super(config);
        this.rsiPeriod = 14;
        this.macdFast = 12;
        this.macdSlow = 26;
    }
    
    async analyze(token) {
        const data = await this.fetchMarketData(token);
        const rsi = this.calculateRSI(data, this.rsiPeriod);
        const macd = this.calculateMACD(data);
        
        return {
            buy: rsi < 30 && macd.histogram > 0,
            sell: rsi > 70 && macd.histogram < 0,
            confidence: this.calculateConfidence(rsi, macd)
        };
    }
    
    async execute(signal) {
        if (signal.confidence > 0.8) {
            const tx = await this.swap({
                token: signal.token,
                amount: this.calculateAmount(signal),
                slippage: 0.5
            });
            
            await this.logTrade(tx);
        }
    }
}

const bot = new MomentumTradingBot({
    network: 'bsc',
    wallet: process.env.WALLET_PRIVATE_KEY
});

bot.start();

class YieldAggregator {
    constructor() {
        this.protocols = [
            'PancakeSwap',
            'Venus',
            'Alpaca',
            'Beefy'
        ];
    }
    
    async findBestYield(asset) {
        const yields = await Promise.all(
            this.protocols.map(protocol => 
                this.getAPY(protocol, asset)
            )
        );
        
        return yields.reduce((best, current) => 
            current.apy > best.apy ? current : best
        );
    }
    
    async autoCompound(pool) {
        const rewards = await pool.getPendingRewards();
        
        if (rewards > this.minCompoundAmount) {
            await pool.harvest();
            await pool.reinvest(rewards);
        }
    }
}