create-stylus-ide 1.0.0

package/ml-training/README.md

@@ -0,0 +1,56 @@
+# ML Model Training for Stylus
+
+This directory contains scripts to train a neural network and export weights for on-chain inference.
+
+## Setup
+
+```bash
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+python -m pip install -U pip
+python -m pip install numpy scikit-learn pandas
+```
+
+## Train Model
+
+```bash
+python train_tiny_model.py
+```
+
+This will:
+
+1. Download MNIST dataset (28x28 digit images)
+2. Train a simple neural network (784 → 32 → 10)
+3. Convert weights to fixed-point format
+4. Export to `frontend/public/ml-weights/model_weights.json`
+5. Save test samples for demo
+
+## Architecture
+
+**Input Layer:** 784 neurons (28×28 pixels, normalized 0-1)
+**Hidden Layer:** 32 neurons (ReLU activation)
+**Output Layer:** 10 neurons (digit 0-9)
+
+**Fixed-Point Format:**
+
+- All weights/biases multiplied by 10,000
+- Stored as i32 in Stylus
+- Divided by 10,000 during inference
+
+## Why Fixed-Point?
+
+Stylus (like EVM) doesn't support floating-point. We use fixed-point arithmetic:
+
+- Float: `0.1234` → Fixed: `1234` (scale: 10000)
+- Multiply: `(a * b) / SCALE`
+- Accurate enough for simple ML
+- Much cheaper than float emulation
+
+## Model Stats
+
+- **Parameters:** ~25,000 weights
+- **Accuracy:** ~95% on MNIST test set
+- **Gas Cost:** TBD (will measure on-chain)

package/ml-training/train_tiny_model.py

@@ -0,0 +1,325 @@
+"""
+Train a TINY neural network that can be embedded on-chain
+Architecture: 784 -> 10 -> 10 (only ~8K parameters)
+Trade-off: Lower accuracy but actually deployable
+"""
+
+import numpy as np
+from sklearn.datasets import fetch_openml
+from sklearn.neural_network import MLPClassifier
+from sklearn.model_selection import train_test_split
+import json
+import re
+# TINY configuration for on-chain deployment
+HIDDEN_LAYER_SIZE = 10  # Very small to reduce weights
+INPUT_SIZE = 784
+OUTPUT_SIZE = 10
+FIXED_POINT_SCALE = 10000
+
+print("Loading MNIST dataset...")
+mnist = fetch_openml('mnist_784', version=1, parser='auto')
+X, y = mnist.data, mnist.target
+
+X = X.to_numpy() if hasattr(X, 'to_numpy') else X
+y = y.to_numpy() if hasattr(y, 'to_numpy') else y
+y = y.astype(int)
+
+# Use more data for better accuracy
+X = X[:30000]
+y = y[:30000]
+
+# Normalize
+X = X / 255.0
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+print(f"Training TINY model: {INPUT_SIZE} -> {HIDDEN_LAYER_SIZE} -> {OUTPUT_SIZE}")
+print(f"Training set: {X_train.shape[0]} samples")
+print(f"Test set: {X_test.shape[0]} samples")
+
+# Train model
+model = MLPClassifier(
+    hidden_layer_sizes=(HIDDEN_LAYER_SIZE,),
+    activation='relu',
+    solver='adam',
+    max_iter=100,
+    random_state=42,
+    verbose=True
+)
+
+model.fit(X_train, y_train)
+
+train_score = model.score(X_train, y_train)
+test_score = model.score(X_test, y_test)
+
+print(f"\nTraining accuracy: {train_score:.4f}")
+print(f"Test accuracy: {test_score:.4f}")
+
+# Extract weights
+w1 = model.coefs_[0]  # (784, 10)
+b1 = model.intercepts_[0]  # (10,)
+w2 = model.coefs_[1]  # (10, 10)
+b2 = model.intercepts_[1]  # (10,)
+
+print(f"\nTotal parameters: {w1.size + b1.size + w2.size + b2.size}")
+
+# Convert to fixed-point
+def to_fixed(arr):
+    return np.round(arr * FIXED_POINT_SCALE).astype(np.int32)
+
+w1_fp = to_fixed(w1)
+b1_fp = to_fixed(b1)
+w2_fp = to_fixed(w2)
+b2_fp = to_fixed(b2)
+
+print("\nGenerating Rust contract code...")
+
+# Generate Rust arrays as strings
+def format_rust_array_2d(arr, name):
+    """Format 2D array as Rust const"""
+    rows, cols = arr.shape
+    lines = [f"const {name}: [[i64; {cols}]; {rows}] = ["]
+    for row in arr:
+        row_str = "    [" + ", ".join(str(int(x)) for x in row) + "],"
+        lines.append(row_str)
+    lines.append("];")
+    return "\n".join(lines)
+
+def format_rust_array_1d(arr, name):
+    """Format 1D array as Rust const"""
+    size = len(arr)
+    values = ", ".join(str(int(x)) for x in arr)
+    return f"const {name}: [i64; {size}] = [{values}];"
+
+# Generate contract with embedded weights
+contract_code = f"""// REAL ML Inference - MNIST (Tiny Model)
+#![cfg_attr(not(feature = "export-abi"), no_main)]
+extern crate alloc;
+
+use stylus_sdk::{{alloy_primitives::U256, prelude::*, alloy_sol_types::sol}};
+use alloc::vec::Vec;
+
+const INPUT_SIZE: usize = {INPUT_SIZE};
+const HIDDEN_SIZE: usize = {HIDDEN_LAYER_SIZE};
+const OUTPUT_SIZE: usize = {OUTPUT_SIZE};
+const SCALE: i64 = {FIXED_POINT_SCALE};
+
+// TRAINED WEIGHTS (Fixed-point scaled by {FIXED_POINT_SCALE})
+// Model accuracy: {test_score:.2%}
+
+{format_rust_array_2d(w1_fp, "WEIGHTS_INPUT_HIDDEN")}
+
+{format_rust_array_1d(b1_fp, "BIAS_HIDDEN")}
+
+{format_rust_array_2d(w2_fp, "WEIGHTS_HIDDEN_OUTPUT")}
+
+{format_rust_array_1d(b2_fp, "BIAS_OUTPUT")}
+
+sol_storage! {{
+    #[entrypoint]
+    pub struct MNISTClassifier {{
+        bool initialized;
+    }}
+}}
+
+#[public]
+impl MNISTClassifier {{
+    // Predict digit from 28x28 grayscale image (784 pixels, 0-255)
+    pub fn predict(&self, pixels: Vec<u8>) -> U256 {{
+        if pixels.len() != INPUT_SIZE {{
+            return U256::from(999); // Error code
+        }}
+
+        // Normalize pixels to fixed-point (0-10000 range)
+        let mut input: Vec<i64> = pixels.iter()
+            .map(|&p| ((p as i64) * SCALE) / 255)
+            .collect();
+
+        // Layer 1: Input -> Hidden (ReLU)
+        let mut hidden = Vec::with_capacity(HIDDEN_SIZE);
+        for i in 0..HIDDEN_SIZE {{
+            let mut sum = BIAS_HIDDEN[i];
+            
+            // Dot product with input
+            for j in 0..INPUT_SIZE {{
+                let weight = WEIGHTS_INPUT_HIDDEN[j][i];
+                sum += (input[j] * weight) / SCALE;
+            }}
+            
+            hidden.push(relu(sum));
+        }}
+
+        // Layer 2: Hidden -> Output
+        let mut output = Vec::with_capacity(OUTPUT_SIZE);
+        for i in 0..OUTPUT_SIZE {{
+            let mut sum = BIAS_OUTPUT[i];
+            
+            // Dot product with hidden layer
+            for j in 0..HIDDEN_SIZE {{
+                let weight = WEIGHTS_HIDDEN_OUTPUT[j][i];
+                sum += (hidden[j] * weight) / SCALE;
+            }}
+            
+            output.push(sum);
+        }}
+
+        // Return argmax (predicted digit)
+        let mut max_idx = 0;
+        let mut max_val = output[0];
+        
+        for i in 1..OUTPUT_SIZE {{
+            if output[i] > max_val {{
+                max_val = output[i];
+                max_idx = i;
+            }}
+        }}
+
+        U256::from(max_idx)
+    }}
+    
+    // Get model info
+    pub fn get_model_info(&self) -> (U256, U256, U256) {{
+        (
+            U256::from(INPUT_SIZE),
+            U256::from(HIDDEN_SIZE),
+            U256::from(OUTPUT_SIZE)
+        )
+    }}
+    
+    // Always ready (weights are embedded)
+    pub fn is_ready(&self) -> bool {{
+        true
+    }}
+}}
+
+// ReLU activation
+fn relu(x: i64) -> i64 {{
+    if x > 0 {{ x }} else {{ 0 }}
+}}
+"""
+
+# Save contract
+with open('../frontend/lib/ml-contract-template.txt', 'w') as f:
+    f.write(contract_code)
+
+print(f"\n✓ Contract saved to: frontend/lib/ml-contract-template.txt")
+
+def escape_for_ts_template_literal(s: str) -> str:
+    # Safe for TypeScript template literals:
+    # - escape backslashes
+    # - escape backticks
+    # - prevent ${} interpolation
+    return s.replace('\\', '\\\\').replace('`', '\\`').replace('${', '\\${')
+
+def find_closing_backtick(text: str, start: int) -> int:
+    """
+    Find the next *unescaped* backtick in `text`, starting at `start`.
+    """
+    i = start
+    while i < len(text):
+        if text[i] == '`':
+            # count preceding backslashes
+            bs = 0
+            j = i - 1
+            while j >= start and text[j] == '\\':
+                bs += 1
+                j -= 1
+            if bs % 2 == 0:
+                return i
+        i += 1
+    return -1
+
+def update_template_code(templates_path: str, template_id: str, new_code: str) -> None:
+    src = open(templates_path, "r", encoding="utf-8").read()
+
+    # 1) Locate the template by id: "ml-inference"
+    m_id = re.search(rf'\bid\s*:\s*["\']{re.escape(template_id)}["\']', src)
+    if not m_id:
+        raise RuntimeError(f'Could not find template id "{template_id}" in {templates_path}')
+
+    # 2) From that point onward, locate: code: `
+    m_code = re.search(r'\bcode\s*:\s*`', src[m_id.end():])
+    if not m_code:
+        raise RuntimeError(f'Could not find `code: ` template literal for id "{template_id}"')
+
+    open_tick = m_id.end() + m_code.end() - 1  # index of the opening ` character
+
+    # 3) Find the matching closing backtick for that template literal
+    close_tick = find_closing_backtick(src, open_tick + 1)
+    if close_tick == -1:
+        raise RuntimeError(f'Could not find closing backtick for template id "{template_id}"')
+
+    # 4) Replace content between backticks
+    escaped = escape_for_ts_template_literal(new_code)
+    updated = src[:open_tick + 1] + escaped + src[close_tick:]
+
+    open(templates_path, "w", encoding="utf-8").write(updated)
+
+# --- AUTO-UPDATE templates.ts ---
+print("\nUpdating frontend/lib/templates.ts...")
+
+try:
+    templates_path = "../frontend/lib/templates.ts"  # your existing path is fine
+    update_template_code(templates_path, "ml-inference", contract_code)
+
+    print("✓ templates.ts updated successfully!")
+    print("✓ ML contract template now has real trained weights")
+    print("\n🎉 Training complete! Refresh your IDE to use the new model.")
+except Exception as e:
+    print(f"⚠️  Error updating templates.ts: {e}")
+    print("Please manually copy from ml-contract-template.txt")
+    import traceback
+    traceback.print_exc()
+
+print(f"\n✓ Model achieves {test_score:.2%} accuracy")
+print(f"✓ Total parameters: {w1.size + b1.size + w2.size + b2.size}")
+print(f"\nNote: Accuracy is lower due to tiny model size")
+print(f"Trade-off: {test_score:.0%} accuracy vs deployable on-chain")
+
+# Save test samples for demo
+print("\nSaving test samples...")
+
+# Get 10 correctly classified samples (one per digit)
+test_samples_by_digit = {i: [] for i in range(10)}
+
+# Find examples of each digit
+for i in range(len(X_test)):
+    label = y_test[i]
+    prediction = model.predict([X_test[i]])[0]
+    
+    # Only save if correctly predicted
+    if prediction == label and len(test_samples_by_digit[label]) < 2:
+        test_samples_by_digit[label].append({
+            'image': X_test[i].tolist(),
+            'label': int(label),
+            'index': i
+        })
+    
+    # Stop when we have 2 examples of each digit
+    if all(len(samples) >= 2 for samples in test_samples_by_digit.values()):
+        break
+
+# Use the first example of each digit
+test_samples = {
+    'images': [test_samples_by_digit[i][0]['image'] for i in range(10)],
+    'labels': [i for i in range(10)],
+    'indices': [test_samples_by_digit[i][0]['index'] for i in range(10)]
+}
+
+import os
+os.makedirs('../frontend/public/ml-weights', exist_ok=True)
+
+with open('../frontend/public/ml-weights/test_samples.json', 'w') as f:
+    json.dump(test_samples, f, indent=2)
+
+print("✓ Test samples saved (correctly classified examples)")
+
+# Print verification info
+print("\nTest sample verification:")
+for i in range(10):
+    img = test_samples['images'][i]
+    label = test_samples['labels'][i]
+    pred = model.predict([img])[0]
+    print(f"  Sample #{i}: Label={label}, Prediction={pred}, {'✓' if pred == label else '✗'}")

package/ml-training/update_template.py

@@ -0,0 +1,59 @@
+"""
+Helper script to update the ML template in templates.ts
+Usage: python update_template.py
+"""
+
+import re
+import sys
+
+def update_ml_template():
+    try:
+        # Read the generated contract
+        with open('../frontend/lib/ml-contract-template.txt', 'r') as f:
+            contract_code = f.read()
+        
+        # Read templates.ts
+        templates_path = '../frontend/lib/templates.ts'
+        with open(templates_path, 'r') as f:
+            content = f.read()
+        
+        # Use regex to find and replace the ML template code
+        # Pattern: finds the ml-inference template and its code section
+        pattern = r"(id: 'ml-inference',\s+name: 'ML Inference \(MNIST\)',\s+description: '[^']+',\s+code: `)([^`]+)(`)"
+        
+        # Escape backticks in contract code
+        escaped_contract = contract_code.replace('`', '\\`')
+        
+        # Replace
+        new_content = re.sub(
+            pattern,
+            r'\1' + escaped_contract + r'\3',
+            content,
+            flags=re.DOTALL
+        )
+        
+        if new_content != content:
+            # Write back
+            with open(templates_path, 'w') as f:
+                f.write(new_content)
+            
+            print("✓ templates.ts updated successfully!")
+            print("✓ ML template now has real trained weights")
+            print("\n🎉 Refresh your IDE to see the changes!")
+            return True
+        else:
+            print("⚠️  No changes made - pattern not found")
+            print("Check that ml-inference template exists in templates.ts")
+            return False
+            
+    except FileNotFoundError as e:
+        print(f"❌ File not found: {e}")
+        print("Make sure you run this from the ml-training directory")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == '__main__':
+    success = update_ml_template()
+    sys.exit(0 if success else 1)

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "create-stylus-ide",
+    "version": "1.0.0",
+    "description": "The Ultimate Web-Based Development Environment for Arbitrum Stylus Smart Contracts",
+    "main": "cli.js",
+    "bin": {
+      "stylus-ide": "./cli.js"
+    },
+    "scripts": {
+      "postinstall": "cd frontend && npm install",
+      "start": "node cli.js",
+      "dev": "cd frontend && npm run dev",
+      "setup": "cd frontend && npm run setup",
+      "check-env": "cd frontend && npm run check-env",
+      "ml:train": "python ml-training/train_tiny_model.py"
+    },
+    "files": [
+      "frontend",
+      "ml-training",
+      "cli.js"
+    ],
+    "keywords": [
+      "ide",
+      "stylus",
+      "nextjs",
+      "ml"
+    ],
+    "author": "Aaditya Srivastava",
+    "license": "ISC"
+  }