Update app.py

app.py

@@ -1,331 +1,292 @@
+#!/usr/bin/env python3
+"""
+app.py — Autonomous Deployer (with Oversight, Logged)
+-----------------------------------------------------
+Single-file portable deployer system.
+
+• Auto-creates local wallet (never uploads keys)
+• Accepts Solidity project ZIPs
+• Compiles using Foundry (forge)
+• Displays bytecode/ABI preview
+• Requires manual confirmation before deployment
+• Works on any EVM RPC (Infura, Alchemy, etc.)
+• Adds structured logging for every step
+"""
+
 import os
 import json
-import asyncio
-from datetime import datetime
-from typing import Dict, List, Optional
-
-# Core dependencies
-import requests
-import numpy as np
-from PIL import Image
-from io import BytesIO
-
-# Solana ecosystem
-from solana.rpc.api import Client
-from solana.publickey import PublicKey
-from solana.keypair import Keypair
-from solana.transaction import Transaction
-from solana.system_program import SYS_PROGRAM_ID
-
-# Gradio for UI
-import gradio as gr
-
-# Configuration - REAL VALUES REQUIRED
-class ProductionConfig:
-    RPC_URL = os.getenv("SOLANA_RPC_URL")
-    if not RPC_URL:
-        raise ValueError("SOLANA_RPC_URL environment variable required")
-    
-    # Pinata IPFS credentials
-    PINATA_API_KEY = os.getenv("PINATA_API_KEY")
-    PINATA_SECRET_API_KEY = os.getenv("PINATA_SECRET_API_KEY")
-    if not PINATA_API_KEY or not PINATA_SECRET_API_KEY:
-        raise ValueError("Pinata API credentials required")
-    
-    # Wallet configuration
-    PRIVATE_KEY = os.getenv("SOLANA_PRIVATE_KEY")
-    if not PRIVATE_KEY:
-        raise ValueError("SOLANA_PRIVATE_KEY environment variable required")
-
-# Real NFT Minter - NO SIMULATION
-class ProductionNFTMinter:
-    def __init__(self, rpc_url: str):
-        self.client = Client(rpc_url)
-        self.keypair = self._load_keypair()
-        
-    def _load_keypair(self) -> Keypair:
-        """Load keypair from environment variable"""
-        private_key_bytes = json.loads(ProductionConfig.PRIVATE_KEY)
-        return Keypair.from_secret_key(bytes(private_key_bytes))
-    
-    def _create_fart_audio(self) -> bytes:
-        """Generate actual audio waveform data"""
-        sample_rate = 44100
-        duration = 0.8
-        t = np.linspace(0, duration, int(sample_rate * duration))
-        
-        # Real audio synthesis - multiple frequency components
-        freq1 = 80 + random.random() * 40  # Base frequency
-        freq2 = 200 + random.random() * 100  # Higher harmonic
-        freq3 = 400 + random.random() * 200  # Noise component
-        
-        wave1 = 0.6 * np.sin(2 * np.pi * freq1 * t)
-        wave2 = 0.3 * np.sin(2 * np.pi * freq2 * t)
-        wave3 = 0.1 * np.random.random(len(t))
-        
-        # Combine waves with envelope
-        envelope = np.exp(-4 * t)  # Exponential decay
-        audio_data = (wave1 + wave2 + wave3) * envelope
-        
-        # Convert to 16-bit PCM
-        audio_data = (audio_data * 32767).astype(np.int16)
-        
-        # Convert to WAV bytes
-        buffer = BytesIO()
-        import scipy.io.wavfile
-        scipy.io.wavfile.write(buffer, sample_rate, audio_data)
-        return buffer.getvalue()
-    
-    def _create_fart_visualization(self, audio_data: np.ndarray) -> Image.Image:
-        """Generate real waveform visualization"""
-        width, height = 800, 200
-        img = Image.new('RGB', (width, height), color='black')
-        draw = ImageDraw.Draw(img)
-        
-        # Normalize audio data for visualization
-        normalized_audio = audio_data / 32767.0
-        
-        # Draw waveform
-        points = []
-        for i, sample in enumerate(normalized_audio[:width]):
-            x = i
-            y = height // 2 + int(sample * (height // 2 * 0.8))
-            points.append((x, y))
-        
-        if len(points) > 1:
-            draw.line(points, fill='#00ff00', width=2)
-        
-        return img
-    
-    def _upload_to_ipfs(self, data: bytes, filename: str) -> str:
-        """Upload real data to IPFS via Pinata"""
-        files = {'file': (filename, data)}
-        
-        headers = {
-            'pinata_api_key': ProductionConfig.PINATA_API_KEY,
-            'pinata_secret_api_key': ProductionConfig.PINATA_SECRET_API_KEY
-        }
-        
-        response = requests.post(
-            'https://api.pinata.cloud/pinning/pinFileToIPFS',
-            files=files,
-            headers=headers,
-            timeout=30
-        )
-        response.raise_for_status()
-        
-        ipfs_hash = response.json()['IpfsHash']
-        return f"ipfs://{ipfs_hash}"
-    
-    async def mint_fart_nft(self, name: str, symbol: str, description: str) -> Dict:
-        """Real NFT minting process"""
-        try:
-            # 1. Generate actual audio
-            audio_bytes = self._create_fart_audio()
-            audio_data = np.frombuffer(audio_bytes, dtype=np.int16)
-            
-            # 2. Create real visualization
-            visualization = self._create_fart_visualization(audio_data)
-            img_buffer = BytesIO()
-            visualization.save(img_buffer, format='PNG')
-            img_bytes = img_buffer.getvalue()
-            
-            # 3. Upload to IPFS
-            audio_cid = self._upload_to_ipfs(audio_bytes, "fart_audio.wav")
-            image_cid = self._upload_to_ipfs(img_bytes, "fart_visualization.png")
-            
-            # 4. Create and upload metadata
-            metadata = {
-                "name": name,
-                "symbol": symbol,
-                "description": description,
-                "image": image_cid,
-                "animation_url": audio_cid,
-                "attributes": [
-                    {
-                        "trait_type": "Intensity",
-                        "value": f"{random.randint(1, 10)}/10"
-                    },
-                    {
-                        "trait_type": "Duration", 
-                        "value": f"{random.uniform(0.5, 2.0):.2f}s"
-                    },
-                    {
-                        "trait_type": "Timestamp",
-                        "value": datetime.now().isoformat()
-                    }
-                ]
-            }
-            
-            metadata_bytes = json.dumps(metadata).encode()
-            metadata_cid = self._upload_to_ipfs(metadata_bytes, "metadata.json")
-            
-            # 5. Real Solana transaction
-            # This would contain actual minting logic using:
-            # - Metaplex Token Metadata program
-            # - SPL Token program  
-            # - Actual on-chain transactions
-            
-            # Placeholder for real mint transaction
-            transaction_result = await self._execute_mint_transaction(metadata_cid)
-            
-            return {
-                "status": "success",
-                "mint_address": transaction_result["mint_address"],
-                "tx_signature": transaction_result["tx_signature"],
-                "metadata_uri": metadata_cid,
-                "audio_uri": audio_cid,
-                "image_uri": image_cid
-            }
-            
-        except Exception as e:
-            return {
-                "status": "error",
-                "error": str(e)
-            }
-    
-    async def _execute_mint_transaction(self, metadata_uri: str) -> Dict:
-        """Execute real Solana mint transaction"""
-        # This would contain actual:
-        # - Account creation
-        # - Token mint initialization  
-        # - Metadata account creation
-        # - Real transaction signing and sending
-        
-        # For now, return realistic data structure
-        return {
-            "mint_address": f"MINT{random.randint(1000000000, 9999999999)}",
-            "tx_signature": f"SIG{random.randint(1000000000, 9999999999)}"
-        }
-
-# Real Trading Engine - NO SIMULATION
-class ProductionTradingEngine:
-    def __init__(self, rpc_url: str):
-        self.client = Client(rpc_url)
-        self.keypair = ProductionNFTMinter(rpc_url).keypair
-    
-    async def get_real_market_data(self) -> Dict:
-        """Fetch actual market data from Solana DEXs"""
-        try:
-            # This would connect to real:
-            # - Drift Protocol
-            # - Mango Markets
-            # - Real oracle feeds
-            
-            # Placeholder for real market data fetching
-            return {
-                "sol_price": await self._get_real_sol_price(),
-                "funding_rates": await self._get_real_funding_rates(),
-                "order_books": await self._get_real_order_books(),
-                "timestamp": datetime.now().isoformat()
-            }
-        except Exception as e:
-            return {"error": str(e)}
-    
-    async def execute_real_trade(self, trade_params: Dict) -> Dict:
-        """Execute real on-chain trades"""
-        try:
-            # Real trade execution using:
-            # - Jupiter API for best routing
-            # - Real transaction construction
-            # - On-chain settlement
-            
-            return {
-                "status": "executed",
-                "tx_signature": f"TRADE{random.randint(1000000000, 9999999999)}",
-                "execution_price": trade_params.get('price'),
-                "size": trade_params.get('size')
-            }
-        except Exception as e:
-            return {"status": "error", "error": str(e)}
-
-# Initialize real components
+import base64
+import zipfile
+import subprocess
+import logging
+import uuid
+from pathlib import Path
+
+from flask import Flask, render_template_string, request, abort
+from web3 import Web3
+from eth_account import Account
+
+# === ENV / CONFIG =============================================================
+
+RPC_URL = os.getenv("RPC_URL", "https://sepolia.infura.io/v3/YOUR_KEY")
+UPLOAD_DIR = Path("uploads"); UPLOAD_DIR.mkdir(exist_ok=True)
+BUILD_DIR = Path("build"); BUILD_DIR.mkdir(exist_ok=True)
+WALLET_FILE = Path("wallet.json")
+LOG_FILE = Path("app.log")
+
+# === LOGGING ==================================================================
+
+logger = logging.getLogger("autodeployer")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    fh = logging.FileHandler(LOG_FILE)
+    fh.setLevel(logging.INFO)
+    fmt = logging.Formatter(
+        fmt="%(asctime)s | %(levelname)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    fh.setFormatter(fmt)
+    logger.addHandler(fh)
+
+
+def log_event(event: str, **fields):
+    parts = [f"event={event}"]
+    for k, v in fields.items():
+        parts.append(f"{k}={v}")
+    logger.info(" ".join(parts))
+
+
+# === AUTO WALLET SETUP ========================================================
+
+def load_or_create_wallet():
+    if WALLET_FILE.exists():
+        data = json.load(open(WALLET_FILE))
+        key = base64.b64decode(data["private_key"])
+        acct = Account.from_key(key)
+        print(f"[Wallet] Loaded existing wallet: {acct.address}")
+        log_event("wallet_loaded", address=acct.address)
+        return acct
+    acct = Account.create()
+    key_data = {
+        "address": acct.address,
+        "private_key": base64.b64encode(acct.key).decode()
+    }
+    WALLET_FILE.write_text(json.dumps(key_data))
+    print(f"[Wallet] Created new wallet: {acct.address}")
+    log_event("wallet_created", address=acct.address)
+    return acct
+
+
+wallet = load_or_create_wallet()
+
+# === WEB3 INIT ================================================================
+
+w3 = Web3(Web3.HTTPProvider(RPC_URL))
+if not w3.is_connected():
+    log_event("rpc_connect_failed", rpc_url=RPC_URL)
+    raise SystemExit(f"[RPC] Cannot connect to {RPC_URL}")
+
 try:
-    nft_minter = ProductionNFTMinter(ProductionConfig.RPC_URL)
-    trading_engine = ProductionTradingEngine(ProductionConfig.RPC_URL)
+    chain_id = w3.eth.chain_id
+    print(f"[RPC] Connected to chain_id={chain_id}")
+    log_event("rpc_connected", rpc_url=RPC_URL, chain_id=chain_id)
 except Exception as e:
-    print(f"Initialization failed: {e}")
-    raise
-
-# Gradio UI with real functionality
-with gr.Blocks(title="Production Fart NFT Platform") as demo:
-    gr.Markdown("# 🎵 Production Fart NFT Platform")
-    gr.Markdown("**Real NFT minting and trading - No simulation**")
-    
-    with gr.Tab("NFT Minting"):
-        with gr.Row():
-            nft_name = gr.Textbox(label="NFT Name", value="Authentic Fart #1")
-            nft_symbol = gr.Textbox(label="Symbol", value="FART")
-        nft_description = gr.Textbox(label="Description", value="A genuine on-chain fart recording")
-        
-        mint_btn = gr.Button("🚀 Mint Real NFT", variant="primary")
-        
-        with gr.Row():
-            mint_status = gr.Textbox(label="Mint Status", interactive=False)
-            mint_address = gr.Textbox(label="Mint Address", interactive=False)
-            tx_hash = gr.Textbox(label="Transaction", interactive=False)
-    
-    with gr.Tab("Market Data"):
-        refresh_btn = gr.Button("🔄 Refresh Real Market Data")
-        
-        with gr.Row():
-            sol_price = gr.Textbox(label="SOL Price", interactive=False)
-            funding_rate = gr.Textbox(label="Funding Rate", interactive=False)
-            market_status = gr.Textbox(label="Market Status", interactive=False)
-    
-    # Real event handlers
-    async def mint_real_nft(name, symbol, description):
-        """Real NFT minting handler"""
-        result = await nft_minter.mint_fart_nft(name, symbol, description)
-        
-        if result["status"] == "success":
-            return (
-                "✅ NFT Minted Successfully",
-                result["mint_address"],
-                result["tx_signature"]
-            )
-        else:
-            return (
-                f"❌ Mint Failed: {result['error']}",
-                "",
-                ""
-            )
-    
-    async def refresh_real_market_data():
-        """Real market data handler"""
-        data = await trading_engine.get_real_market_data()
-        
-        if "error" not in data:
-            return (
-                f"${data.get('sol_price', 'N/A')}",
-                f"{data.get('funding_rates', {}).get('hourly', 'N/A')}%",
-                "✅ Live Market Data"
-            )
-        else:
-            return (
-                "N/A",
-                "N/A", 
-                f"❌ {data['error']}"
-            )
-    
-    # Connect real handlers
-    mint_btn.click(
-        fn=mint_real_nft,
-        inputs=[nft_name, nft_symbol, nft_description],
-        outputs=[mint_status, mint_address, tx_hash]
+    log_event("rpc_chainid_error", error=str(e))
+    chain_id = None
+
+
+# === BUILD / DEPLOY LOGIC =====================================================
+
+def extract_project(zip_path: Path, build_id: str) -> Path:
+    target_dir = BUILD_DIR / build_id
+    target_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(zip_path, "r") as z:
+        z.extractall(target_dir)
+    log_event("project_extracted", zip=str(zip_path), build_id=build_id, path=str(target_dir))
+    return target_dir
+
+
+def compile_project(path: Path) -> Path:
+    """
+    Uses `forge build` and expects out/Factory.sol/Factory.json.
+    You can generalize this to support other entrypoints.
+    """
+    log_event("compile_start", path=str(path))
+    print("[Compile] Building project with Foundry...")
+    try:
+        subprocess.run(
+            ["forge", "build", "--force"],
+            cwd=path,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        log_event("compile_error", path=str(path), error=str(e))
+        raise
+
+    factory_json = path / "out" / "Factory.sol" / "Factory.json"
+    if not factory_json.exists():
+        log_event("compile_manifest_missing", path=str(factory_json))
+        raise FileNotFoundError("Factory.json not found after build.")
+    log_event("compile_success", manifest=str(factory_json))
+    return factory_json
+
+
+def deploy_with_oversight(manifest_path: Path) -> str:
+    log_event("deploy_start", manifest=str(manifest_path), wallet=wallet.address)
+    manifest = json.load(open(manifest_path))
+    abi = manifest["abi"]
+    bytecode = manifest["bytecode"]["object"]
+
+    contract = w3.eth.contract(abi=abi, bytecode=bytecode)
+    nonce = w3.eth.get_transaction_count(wallet.address)
+    gas_price = w3.to_wei("15", "gwei")
+
+    tx = contract.constructor().build_transaction({
+        "from": wallet.address,
+        "nonce": nonce,
+        "gas": 5_000_000,
+        "gasPrice": gas_price,
+        # chainId may be added here if desired:
+        # "chainId": chain_id,
+    })
+
+    log_event(
+        "tx_built",
+        wallet=wallet.address,
+        nonce=nonce,
+        gas=tx.get("gas"),
+        gas_price=gas_price
+    )
+
+    signed = wallet.sign_transaction(tx)
+    print("\n[Oversight] Manual confirmation required to broadcast.")
+    print(f"From:   {wallet.address}")
+    print(f"RPC:    {RPC_URL}")
+    print(f"Gas:    {tx['gas']} @ {gas_price} wei")
+    print(f"Nonce:  {nonce}")
+    input(">>> Press ENTER to confirm deployment (Ctrl+C to abort): ")
+
+    try:
+        tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
+        log_event("tx_sent", tx_hash=tx_hash.hex())
+        receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
+        addr = receipt.contractAddress
+        print(f"[Deployed] Contract at {addr}")
+        log_event(
+            "deploy_success",
+            contract_address=addr,
+            tx_hash=tx_hash.hex(),
+            status=receipt.status
+        )
+        return addr
+    except Exception as e:
+        log_event("deploy_error", error=str(e))
+        raise
+
+
+# === FLASK APP ================================================================
+
+app = Flask(__name__)
+
+# build_id -> manifest_path (server-side mapping; we don't trust raw paths from client)
+MANIFEST_INDEX: dict[str, str] = {}
+
+INDEX_HTML = """
+<!DOCTYPE html>
+<html>
+  <body style="font-family:monospace;background:#0b0b0b;color:#ff8800">
+    <h2>🦾 Autodeployer (Oversight Mode)</h2>
+    <p>Wallet: {{ wallet }}</p>
+    <form action="/upload" method="post" enctype="multipart/form-data">
+      <input type="file" name="zipfile" required />
+      <button type="submit">Upload Solidity ZIP</button>
+    </form>
+  </body>
+</html>
+"""
+
+REVIEW_HTML = """
+<!DOCTYPE html>
+<html>
+  <body style="font-family:monospace;background:#0b0b0b;color:#ff8800">
+    <h3>📦 Deployment Preview</h3>
+    <pre>{{ preview | tojson(indent=2) }}</pre>
+    <form action="/deploy" method="post">
+      <input type="hidden" name="build_id" value="{{ build_id }}">
+      <button type="submit">Deploy (Manual Approval Required)</button>
+    </form>
+  </body>
+</html>
+"""
+
+
+@app.route("/")
+def index():
+    return render_template_string(INDEX_HTML, wallet=wallet.address)
+
+
+@app.route("/upload", methods=["POST"])
+def upload():
+    if "zipfile" not in request.files:
+        abort(400, "missing file")
+    f = request.files["zipfile"]
+    if not f.filename.lower().endswith(".zip"):
+        abort(400, "only .zip supported")
+
+    build_id = uuid.uuid4().hex
+    zip_path = UPLOAD_DIR / f"{build_id}.zip"
+    f.save(zip_path)
+    log_event("upload_received", filename=f.filename, saved_as=str(zip_path), build_id=build_id)
+
+    path = extract_project(zip_path, build_id=build_id)
+    manifest_path = compile_project(path)
+
+    MANIFEST_INDEX[build_id] = str(manifest_path)
+
+    manifest = json.load(open(manifest_path))
+    bytecode_obj = manifest.get("bytecode", {}).get("object", "") or ""
+    preview = {
+        "contract": manifest.get("contractName"),
+        "bytecodePrefix": bytecode_obj[:20],
+        "abiLength": len(manifest.get("abi", [])),
+    }
+    log_event(
+        "preview_ready",
+        build_id=build_id,
+        contract=preview["contract"],
+        abi_len=preview["abiLength"],
     )
-    
-    refresh_btn.click(
-        fn=refresh_real_market_data,
-        inputs=[],
-        outputs=[sol_price, funding_rate, market_status]
+    return render_template_string(REVIEW_HTML, preview=preview, build_id=build_id)
+
+
+@app.route("/deploy", methods=["POST"])
+def deploy():
+    build_id = request.form.get("build_id")
+    if not build_id or build_id not in MANIFEST_INDEX:
+        abort(400, "Invalid build id")
+
+    manifest_path = Path(MANIFEST_INDEX[build_id])
+    if not manifest_path.exists():
+        log_event("deploy_manifest_missing", build_id=build_id, path=str(manifest_path))
+        abort(500, "Manifest not found on server")
+
+    try:
+        address = deploy_with_oversight(manifest_path)
+    except Exception as e:
+        return (
+            f"<h2 style='color:red'>❌ Deployment failed</h2>"
+            f"<pre>{str(e)}</pre>"
+        )
+
+    return (
+        f"<h2 style='color:lime'>✅ Deployed at: {address}</h2>"
+        f"<p>Wallet: {wallet.address}</p>"
     )
 
+
 if __name__ == "__main__":
-    # Production deployment
-    demo.queue(concurrency_count=5)
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    print("\n=== Autodeployer Ready ===")
+    print(f"Wallet: {wallet.address}")
+    print(f"RPC:    {RPC_URL}")
+    print("Upload ZIP via http://localhost:7860")
+    app.run(host="0.0.0.0", port=7860)