v0.0.1 - Up and running

.gitignore

@@ -0,0 +1,26 @@
+# Build artifacts
+superball_thrower
+*.o
+*.a
+*.so
+
+# Configuration
+config.json
+
+# Logs
+*.log
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.bak

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "nostr_core_lib"]
+	path = nostr_core_lib
+	url = https://git.laantungir.net/laantungir/nostr_core_lib.git

.test_keys

@@ -0,0 +1,4 @@
+ADMIN_PRIVKEY='22cc83aa57928a2800234c939240c9a6f0f44a33ea3838a860ed38930b195afd'
+ADMIN_PUBKEY='8ff74724ed641b3c28e5a86d7c5cbc49c37638ace8c6c38935860e7a5eedde0e'
+SERVER_PRIVKEY='c4e0d2ed7d36277d6698650f68a6e9199f91f3abb476a67f07303e81309c48f1'
+SERVER_PUBKEY='52e366edfa4e9cc6a6d4653828e51ccf828a2f5a05227d7a768f33b5a198681a'

Makefile

@@ -0,0 +1,26 @@
+CC = gcc
+CFLAGS = -Wall -Wextra -O2 -I./nostr_core_lib/nostr_core -I./nostr_core_lib/cjson
+LDFLAGS = ./nostr_core_lib/libnostr_core_x64.a -lz -ldl -lpthread -lm -L/usr/local/lib -lsecp256k1 -lssl -lcrypto -L/usr/local/lib -lcurl
+
+TARGET = superball_thrower
+SOURCE = main.c
+
+all: nostr_core_lib $(TARGET)
+
+nostr_core_lib:
+	@echo "Building nostr_core_lib..."
+	cd nostr_core_lib && ./build.sh --nips=1,6,44
+
+$(TARGET): $(SOURCE)
+	$(CC) $(CFLAGS) $(SOURCE) -o $(TARGET) $(LDFLAGS)
+
+clean:
+	rm -f $(TARGET)
+
+distclean: clean
+	cd nostr_core_lib && make clean
+
+install: $(TARGET)
+	install -m 755 $(TARGET) /usr/local/bin/
+
+.PHONY: all clean distclean install nostr_core_lib

README.md

@@ -1,4 +1,308 @@
-Thrower
+# Superball Thrower - C Implementation
 
-This is an implementaion of a superball thower written in C99
+A high-performance, privacy-focused Superball Thrower daemon implemented in C using the nostr_core_lib.
 
+## Overview
+
+This is a C implementation of the Superball protocol (SUP-01 through SUP-06), providing anonymizing relay services for Nostr events. The thrower catches, unwraps, rewraps, and throws Superballs (wrapped encrypted events) with timing delays and size obfuscation to provide location privacy for Nostr users.
+
+## Features
+
+- **Full Protocol Support**: Implements SUP-01 through SUP-06
+- **NIP-44 Encryption**: Modern ChaCha20-based encryption for payload protection
+- **Dual Payload Handling**: Supports both routing payloads (from builder) and padding payloads (from previous thrower)
+- **Double Decryption**: Automatically handles padding payloads requiring two decryption steps
+- **Event Queue**: Delayed processing with configurable delays and random jitter
+- **Relay Management**: Automatic authentication testing and capability detection
+- **Thrower Info Publishing**: SUP-06 compliant service announcements with auto-refresh
+- **High Performance**: Written in C for minimal resource usage and maximum throughput
+
+## Architecture
+
+The implementation uses a simplified single-file architecture in `main.c` (~1800 lines) with the following organization:
+
+1. **Includes & Constants** - System headers and configuration
+2. **Data Structures** - All structs and type definitions
+3. **Utility Functions** - Logging, time, padding generation
+4. **Configuration Functions** - JSON config loading and parsing
+5. **Crypto Functions** - NIP-44 encryption/decryption wrappers
+6. **Queue Functions** - Thread-safe event queue management
+7. **Relay Functions** - Relay authentication and management
+8. **Event Processing Functions** - Core protocol logic
+9. **Thrower Info Functions** - SUP-06 publishing with auto-refresh
+10. **Main Functions** - Initialization and event loop
+
+## Dependencies
+
+- **nostr_core_lib** (git submodule) - Provides all NOSTR protocol operations
+- **OpenSSL** - Cryptographic operations
+- **libcurl** - HTTP/WebSocket communication
+- **libsecp256k1** - Elliptic curve cryptography
+- **pthread** - Multi-threading support
+
+## Building
+
+### Prerequisites
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install build-essential libssl-dev libcurl4-openssl-dev libsecp256k1-dev
+
+# Fedora/RHEL
+sudo dnf install gcc make openssl-devel libcurl-devel libsecp256k1-devel
+
+# macOS
+brew install openssl curl libsecp256k1
+```
+
+### Build Steps
+
+```bash
+# Clone the repository with submodules
+git clone --recursive https://git.laantungir.net/laantungir/super_ball_thrower.git
+cd super_ball_thrower
+
+# Build everything (including nostr_core_lib)
+make
+
+# The binary will be created as: ./superball_thrower
+```
+
+### Build Commands
+
+```bash
+make              # Build everything
+make clean        # Clean build artifacts
+make distclean    # Clean everything including nostr_core_lib
+sudo make install # Install to /usr/local/bin
+```
+
+## Configuration
+
+### Create Configuration File
+
+```bash
+# Copy example configuration
+cp config.example.json config.json
+
+# Edit with your settings
+nano config.json
+```
+
+### Configuration Format
+
+```json
+{
+  "thrower": {
+    "privateKey": "your_64_character_hex_private_key_here",
+    "name": "My C Superball Thrower",
+    "description": "High-performance C implementation",
+    "maxDelay": 86460,
+    "refreshRate": 300,
+    "supportedSups": "1,2,3,4,5,6",
+    "software": "https://git.laantungir.net/laantungir/super_ball_thrower.git",
+    "version": "1.0.0"
+  },
+  "relays": [
+    {
+      "url": "wss://relay.laantungir.net",
+      "read": true,
+      "write": true
+    }
+  ],
+  "daemon": {
+    "logLevel": "info",
+    "maxQueueSize": 1000
+  }
+}
+```
+
+### Configuration Options
+
+#### Thrower Section
+- **privateKey**: Your thrower's private key (64-character hex string)
+- **name**: Display name for your thrower
+- **description**: Description of your thrower service
+- **maxDelay**: Maximum delay in seconds (default: 86460 = ~24 hours)
+- **refreshRate**: How often to republish thrower info in seconds (default: 300)
+- **supportedSups**: Comma-separated list of supported SUPs (default: "1,2,3,4,5,6")
+- **software**: URL to your thrower software
+- **version**: Version string
+
+#### Relays Section
+- **url**: WebSocket URL of the relay
+- **read**: Enable reading events from this relay
+- **write**: Enable writing events to this relay
+
+#### Daemon Section
+- **logLevel**: Logging verbosity: "debug", "info", "warn", "error"
+- **maxQueueSize**: Maximum number of events to queue (default: 1000)
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Run with default config.json
+./superball_thrower
+
+# Run with custom config file
+./superball_thrower /path/to/config.json
+
+# Show help
+./superball_thrower --help
+```
+
+### Running as a Service
+
+#### systemd Service (Linux)
+
+Create `/etc/systemd/system/superball-thrower.service`:
+
+```ini
+[Unit]
+Description=Superball Thrower Daemon
+After=network.target
+
+[Service]
+Type=simple
+User=superball
+WorkingDirectory=/opt/superball_thrower
+ExecStart=/opt/superball_thrower/superball_thrower /opt/superball_thrower/config.json
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Enable and start:
+
+```bash
+sudo systemctl enable superball-thrower
+sudo systemctl start superball-thrower
+sudo systemctl status superball-thrower
+```
+
+View logs:
+
+```bash
+sudo journalctl -u superball-thrower -f
+```
+
+## Protocol Flow
+
+### Single Unwrapping (Routing Payload)
+1. **Receive**: Kind 22222 event with thrower's pubkey in p tag
+2. **Decrypt**: Get payload with routing instructions from builder
+3. **Process**: Routing instructions were created specifically for this thrower
+4. **Forward or Post**: Based on presence of `routing.p` field
+
+### Double Unwrapping (Padding Payload)
+1. **Receive**: Kind 22222 event with thrower's pubkey in p tag
+2. **First Decrypt**: Get padding payload - discard padding data
+3. **Second Decrypt**: Decrypt inner event to get routing instructions
+4. **Process**: Routing instructions were created specifically for this thrower
+5. **Forward or Post**: Based on presence of `routing.p` field
+
+### Forwarding Logic
+- **If `routing.p` present**: Forward to next thrower with padding wrapper
+- **If `routing.p` missing**: Post inner event directly to relays (end of chain)
+
+## Performance
+
+Expected performance characteristics:
+
+- **Throughput**: 100+ events/second
+- **Memory Usage**: <100MB RAM
+- **Latency**: <100ms processing time per event
+- **Reliability**: 99.9% uptime in 24-hour operation
+
+## Security Considerations
+
+1. **Private Key Protection**: Store private key securely, never commit to version control
+2. **Relay Authentication**: Only writes to relays that don't require AUTH
+3. **Memory Safety**: All decrypted data cleared after processing
+4. **No Logging**: Sensitive routing information never logged
+5. **Fresh Keys**: Uses ephemeral keys for each forwarding operation
+
+## Troubleshooting
+
+### Build Issues
+
+```bash
+# If nostr_core_lib fails to build
+cd nostr_core_lib
+./build.sh lib
+cd ..
+make
+```
+
+### Runtime Issues
+
+```bash
+# Enable debug logging
+# Edit config.json and set "logLevel": "debug"
+
+# Check relay connectivity
+# Verify relay URLs are accessible via WebSocket
+
+# Verify private key format
+# Must be 64-character hex string (32 bytes)
+```
+
+## Development
+
+### Project Structure
+
+```
+super_ball_thrower/
+├── main.c                       # Complete implementation
+├── Makefile                     # Build system
+├── config.example.json          # Example configuration
+├── config.json                  # User configuration (gitignored)
+├── README.md                    # This file
+├── nostr_core_lib/              # Git submodule
+└── plans/
+    └── superball_thrower_c_architecture.md
+```
+
+### Testing with Node.js Implementation
+
+The C implementation is fully compatible with the Node.js reference implementation. You can test interoperability by:
+
+1. Running both implementations simultaneously
+2. Sending test events through the routing chain
+3. Verifying events are properly forwarded and posted
+
+## Contributing
+
+Contributions are welcome! Please:
+
+1. Follow the existing code style
+2. Add tests for new features
+3. Update documentation
+4. Submit pull requests to the main repository
+
+## License
+
+MIT License - See LICENSE file for details
+
+## References
+
+- [Superball Protocol Documentation](super_ball/SUPs.md)
+- [Thrower Rules](super_ball/THROWER.md)
+- [nostr_core_lib](https://git.laantungir.net/laantungir/nostr_core_lib)
+- [NOSTR Protocol](https://github.com/nostr-protocol/nostr)
+
+## Support
+
+For issues, questions, or contributions:
+- Repository: https://git.laantungir.net/laantungir/super_ball_thrower
+- Issues: Use the repository issue tracker
+
+---
+
+**Version**: 1.0.0  
+**Author**: Roo (Code Mode)  
+**Last Updated**: 2025-12-10

config.example.json

@@ -0,0 +1,33 @@
+{
+  "thrower": {
+    "privateKey": "your_64_character_hex_private_key_here_replace_this_with_real_key",
+    "name": "My C Superball Thrower",
+    "description": "High-performance C implementation of Superball Thrower",
+    "maxDelay": 86460,
+    "refreshRate": 300,
+    "supportedSups": "1,2,3,4,5,6",
+    "software": "https://git.laantungir.net/laantungir/super_ball_thrower.git",
+    "version": "1.0.0"
+  },
+  "relays": [
+    {
+      "url": "wss://relay.laantungir.net",
+      "read": true,
+      "write": true
+    },
+    {
+      "url": "wss://relay.damus.io",
+      "read": true,
+      "write": true
+    },
+    {
+      "url": "wss://nos.lol",
+      "read": true,
+      "write": true
+    }
+  ],
+  "daemon": {
+    "logLevel": "info",
+    "maxQueueSize": 1000
+  }
+}

increment_and_push.sh

@@ -0,0 +1,456 @@
+#!/bin/bash
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
+print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
+print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
+print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+
+# Global variables
+COMMIT_MESSAGE=""
+RELEASE_MODE=false
+
+# TODO: Update this URL to match your actual Gitea repository
+GITEA_REPO_URL="https://git.laantungir.net/api/v1/repos/laantungir/super_ball_thrower"
+
+# Function definitions must come before usage
+show_usage() {
+    echo "Superball Thrower Build and Push Script"
+    echo ""
+    echo "Usage:"
+    echo "  $0 \"commit message\"           - Default: compile, increment patch, commit & push"
+    echo "  $0 -r \"commit message\"        - Release: compile, increment minor, create release"
+    echo ""
+    echo "Examples:"
+    echo "  $0 \"Fixed event processing bug\""
+    echo "  $0 --release \"Major release with SUP-06 support\""
+    echo ""
+    echo "Default Mode (patch increment):"
+    echo "  - Compile Superball Thrower daemon"
+    echo "  - Increment patch version (v1.2.3 → v1.2.4)"
+    echo "  - Git add, commit with message, and push"
+    echo ""
+    echo "Release Mode (-r flag):"
+    echo "  - Compile Superball Thrower daemon"
+    echo "  - Increment minor version, zero patch (v1.2.3 → v1.3.0)"
+    echo "  - Git add, commit, push, and create Gitea release"
+    echo ""
+    echo "Requirements for Release Mode:"
+    echo "  - Gitea token in ~/.gitea_token for release uploads"
+    echo "  - Update GITEA_REPO_URL in script for your repository"
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -r|--release)
+            RELEASE_MODE=true
+            shift
+            ;;
+        -h|--help)
+            show_usage
+            exit 0
+            ;;
+        *)
+            # First non-flag argument is the commit message
+            if [[ -z "$COMMIT_MESSAGE" ]]; then
+                COMMIT_MESSAGE="$1"
+            fi
+            shift
+            ;;
+    esac
+done
+
+# Validate inputs
+if [[ -z "$COMMIT_MESSAGE" ]]; then
+    print_error "Commit message is required"
+    echo ""
+    show_usage
+    exit 1
+fi
+
+# Check if we're in a git repository
+check_git_repo() {
+    if ! git rev-parse --git-dir > /dev/null 2>&1; then
+        print_error "Not in a git repository"
+        exit 1
+    fi
+}
+
+# Function to get current version and increment appropriately
+increment_version() {
+    local increment_type="$1"  # "patch" or "minor"
+    
+    print_status "Getting current version..."
+    
+    # Get the highest version tag (not chronologically latest)
+    LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "")
+    if [[ -z "$LATEST_TAG" ]]; then
+        LATEST_TAG="v0.0.0"
+        print_warning "No version tags found, starting from $LATEST_TAG"
+    fi
+    
+    # Extract version components (remove 'v' prefix)
+    VERSION=${LATEST_TAG#v}
+    
+    # Parse major.minor.patch using regex
+    if [[ $VERSION =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+        MAJOR=${BASH_REMATCH[1]}
+        MINOR=${BASH_REMATCH[2]}
+        PATCH=${BASH_REMATCH[3]}
+    else
+        print_error "Invalid version format in tag: $LATEST_TAG"
+        print_error "Expected format: v0.1.0"
+        exit 1
+    fi
+    
+    # Increment version based on type
+    if [[ "$increment_type" == "minor" ]]; then
+        # Minor release: increment minor, zero patch
+        NEW_MINOR=$((MINOR + 1))
+        NEW_PATCH=0
+        NEW_VERSION="v${MAJOR}.${NEW_MINOR}.${NEW_PATCH}"
+        print_status "Release mode: incrementing minor version"
+    else
+        # Default: increment patch
+        NEW_PATCH=$((PATCH + 1))
+        NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
+        print_status "Default mode: incrementing patch version"
+    fi
+    
+    print_status "Current version: $LATEST_TAG"
+    print_status "New version: $NEW_VERSION"
+    
+    # Export for use in other functions
+    export NEW_VERSION
+}
+
+# Function to update version in main.c
+update_version_in_code() {
+    local version="$1"
+    print_status "Updating version in main.c to $version..."
+
+    # Update the THROWER_VERSION define in main.c
+    sed -i "s/#define THROWER_VERSION \"v[0-9]\+\.[0-9]\+\.[0-9]\+\"/#define THROWER_VERSION \"$version\"/" main.c
+
+    print_success "Updated version in main.c"
+}
+
+# Function to compile the Superball Thrower project
+compile_project() {
+    print_status "Compiling Superball Thrower daemon..."
+
+    # Clean previous build
+    if make clean > /dev/null 2>&1; then
+        print_success "Cleaned previous build"
+    else
+        print_warning "Clean failed or no Makefile found"
+    fi
+
+    # Compile the project
+    if make > /dev/null 2>&1; then
+        print_success "Superball Thrower compiled successfully"
+
+        # Verify the binary was created
+        if [[ -f "superball_thrower" ]]; then
+            print_success "Binary created: superball_thrower"
+        else
+            print_error "Binary not found after compilation"
+            exit 1
+        fi
+    else
+        print_error "Compilation failed"
+        exit 1
+    fi
+}
+
+# Function to build release binary
+build_release_binary() {
+    print_status "Building release binary..."
+    
+    # Build the Superball Thrower daemon
+    print_status "Building Superball Thrower daemon..."
+    make clean > /dev/null 2>&1
+    if make > /dev/null 2>&1; then
+        if [[ -f "superball_thrower" ]]; then
+            cp superball_thrower superball_thrower-linux-x86_64
+            print_success "Release binary created: superball_thrower-linux-x86_64"
+        else
+            print_error "Binary not found after compilation"
+            exit 1
+        fi
+    else
+        print_error "Build failed"
+        exit 1
+    fi
+}
+
+# Function to commit and push changes
+git_commit_and_push() {
+    print_status "Preparing git commit..."
+    
+    # Stage all changes
+    if git add . > /dev/null 2>&1; then
+        print_success "Staged all changes"
+    else
+        print_error "Failed to stage changes"
+        exit 1
+    fi
+    
+    # Check if there are changes to commit
+    if git diff --staged --quiet; then
+        print_warning "No changes to commit"
+    else
+        # Commit changes
+        if git commit -m "$NEW_VERSION - $COMMIT_MESSAGE" > /dev/null 2>&1; then
+            print_success "Committed changes"
+        else
+            print_error "Failed to commit changes"
+            exit 1
+        fi
+    fi
+    
+    # Create new git tag
+    if git tag "$NEW_VERSION" > /dev/null 2>&1; then
+        print_success "Created tag: $NEW_VERSION"
+    else
+        print_warning "Tag $NEW_VERSION already exists"
+    fi
+    
+    # Push changes and tags
+    print_status "Pushing to remote repository..."
+    if git push > /dev/null 2>&1; then
+        print_success "Pushed changes"
+    else
+        print_error "Failed to push changes"
+        exit 1
+    fi
+    
+    # Push only the new tag to avoid conflicts with existing tags
+    if git push origin "$NEW_VERSION" > /dev/null 2>&1; then
+        print_success "Pushed tag: $NEW_VERSION"
+    else
+        print_warning "Tag push failed, trying force push..."
+        if git push --force origin "$NEW_VERSION" > /dev/null 2>&1; then
+            print_success "Force-pushed updated tag: $NEW_VERSION"
+        else
+            print_error "Failed to push tag: $NEW_VERSION"
+            exit 1
+        fi
+    fi
+}
+
+# Function to commit and push changes without creating a tag (tag already created)
+git_commit_and_push_no_tag() {
+    print_status "Preparing git commit..."
+    
+    # Stage all changes
+    if git add . > /dev/null 2>&1; then
+        print_success "Staged all changes"
+    else
+        print_error "Failed to stage changes"
+        exit 1
+    fi
+    
+    # Check if there are changes to commit
+    if git diff --staged --quiet; then
+        print_warning "No changes to commit"
+    else
+        # Commit changes
+        if git commit -m "$NEW_VERSION - $COMMIT_MESSAGE" > /dev/null 2>&1; then
+            print_success "Committed changes"
+        else
+            print_error "Failed to commit changes"
+            exit 1
+        fi
+    fi
+    
+    # Push changes and tags
+    print_status "Pushing to remote repository..."
+    if git push > /dev/null 2>&1; then
+        print_success "Pushed changes"
+    else
+        print_error "Failed to push changes"
+        exit 1
+    fi
+    
+    # Push only the new tag to avoid conflicts with existing tags
+    if git push origin "$NEW_VERSION" > /dev/null 2>&1; then
+        print_success "Pushed tag: $NEW_VERSION"
+    else
+        print_warning "Tag push failed, trying force push..."
+        if git push --force origin "$NEW_VERSION" > /dev/null 2>&1; then
+            print_success "Force-pushed updated tag: $NEW_VERSION"
+        else
+            print_error "Failed to push tag: $NEW_VERSION"
+            exit 1
+        fi
+    fi
+}
+
+# Function to create Gitea release
+create_gitea_release() {
+    print_status "Creating Gitea release..."
+    
+    # Check for Gitea token
+    if [[ ! -f "$HOME/.gitea_token" ]]; then
+        print_warning "No ~/.gitea_token found. Skipping release creation."
+        print_warning "Create ~/.gitea_token with your Gitea access token to enable releases."
+        return 0
+    fi
+    
+    local token=$(cat "$HOME/.gitea_token" | tr -d '\n\r')
+    
+    # Create release
+    print_status "Creating release $NEW_VERSION..."
+    local response=$(curl -s -X POST "$GITEA_REPO_URL/releases" \
+         -H "Authorization: token $token" \
+         -H "Content-Type: application/json" \
+         -d "{\"tag_name\": \"$NEW_VERSION\", \"name\": \"$NEW_VERSION\", \"body\": \"$COMMIT_MESSAGE\"}")
+    
+    if echo "$response" | grep -q '"id"'; then
+        print_success "Created release $NEW_VERSION"
+        upload_release_binary "$token"
+    elif echo "$response" | grep -q "already exists"; then
+        print_warning "Release $NEW_VERSION already exists"
+        upload_release_binary "$token"
+    else
+        print_error "Failed to create release $NEW_VERSION"
+        print_error "Response: $response"
+        
+        # Try to check if the release exists anyway
+        print_status "Checking if release exists..."
+        local check_response=$(curl -s -H "Authorization: token $token" "$GITEA_REPO_URL/releases/tags/$NEW_VERSION")
+        if echo "$check_response" | grep -q '"id"'; then
+            print_warning "Release exists but creation response was unexpected"
+            upload_release_binary "$token"
+        else
+            print_error "Release does not exist and creation failed"
+            return 1
+        fi
+    fi
+}
+
+# Function to upload release binary
+upload_release_binary() {
+    local token="$1"
+    
+    # Get release ID with more robust parsing
+    print_status "Getting release ID for $NEW_VERSION..."
+    local response=$(curl -s -H "Authorization: token $token" "$GITEA_REPO_URL/releases/tags/$NEW_VERSION")
+    local release_id=$(echo "$response" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+    
+    if [[ -z "$release_id" ]]; then
+        print_error "Could not get release ID for $NEW_VERSION"
+        print_error "API Response: $response"
+        
+        # Try to list all releases to debug
+        print_status "Available releases:"
+        curl -s -H "Authorization: token $token" "$GITEA_REPO_URL/releases" | grep -o '"tag_name":"[^"]*"' | head -5
+        return 1
+    fi
+    
+    print_success "Found release ID: $release_id"
+    
+    # Upload Superball Thrower binary
+    if [[ -f "superball_thrower-linux-x86_64" ]]; then
+        print_status "Uploading Superball Thrower binary..."
+        if curl -s -X POST "$GITEA_REPO_URL/releases/$release_id/assets" \
+                -H "Authorization: token $token" \
+                -F "attachment=@superball_thrower-linux-x86_64;filename=superball_thrower-${NEW_VERSION}-linux-x86_64" > /dev/null; then
+            print_success "Uploaded Superball Thrower binary"
+        else
+            print_warning "Failed to upload Superball Thrower binary"
+        fi
+    fi
+}
+
+# Function to clean up release binary
+cleanup_release_binary() {
+    if [[ -f "superball_thrower-linux-x86_64" ]]; then
+        rm -f superball_thrower-linux-x86_64
+        print_status "Cleaned up release binary"
+    fi
+}
+
+# Main execution
+main() {
+    print_status "Superball Thrower Build and Push Script"
+    
+    # Check prerequisites
+    check_git_repo
+    
+    if [[ "$RELEASE_MODE" == true ]]; then
+        print_status "=== RELEASE MODE ==="
+        
+        # Increment minor version for releases
+        increment_version "minor"
+        
+        # Create new git tag BEFORE compilation
+        if git tag "$NEW_VERSION" > /dev/null 2>&1; then
+            print_success "Created tag: $NEW_VERSION"
+        else
+            print_warning "Tag $NEW_VERSION already exists, removing and recreating..."
+            git tag -d "$NEW_VERSION" > /dev/null 2>&1
+            git tag "$NEW_VERSION" > /dev/null 2>&1
+        fi
+        
+        # Update version in main.c
+        update_version_in_code "$NEW_VERSION"
+
+        # Compile project
+        compile_project
+
+        # Build release binary
+        build_release_binary
+        
+        # Commit and push (but skip tag creation since we already did it)
+        git_commit_and_push_no_tag
+        
+        # Create Gitea release with binary
+        create_gitea_release
+        
+        # Cleanup
+        cleanup_release_binary
+        
+        print_success "Release $NEW_VERSION completed successfully!"
+        print_status "Binary uploaded to Gitea release"
+        
+    else
+        print_status "=== DEFAULT MODE ==="
+        
+        # Increment patch version for regular commits
+        increment_version "patch"
+        
+        # Create new git tag BEFORE compilation
+        if git tag "$NEW_VERSION" > /dev/null 2>&1; then
+            print_success "Created tag: $NEW_VERSION"
+        else
+            print_warning "Tag $NEW_VERSION already exists, removing and recreating..."
+            git tag -d "$NEW_VERSION" > /dev/null 2>&1
+            git tag "$NEW_VERSION" > /dev/null 2>&1
+        fi
+        
+        # Update version in main.c
+        update_version_in_code "$NEW_VERSION"
+
+        # Compile project
+        compile_project
+
+        # Commit and push (but skip tag creation since we already did it)
+        git_commit_and_push_no_tag
+        
+        print_success "Build and push completed successfully!"
+        print_status "Version $NEW_VERSION pushed to repository"
+    fi
+}
+
+# Execute main function
+main

plans/superball_thrower_c_architecture.md

@@ -0,0 +1,516 @@
+# Superball Thrower C Implementation - Simplified Architecture
+
+## Executive Summary
+
+This document outlines a **simplified single-file architecture** for implementing a Superball Thrower daemon in C using the nostr_core_lib submodule. The implementation will follow the Superball protocol (SUP-01 through SUP-06) and provide equivalent functionality to the reference Node.js implementation.
+
+**Implementation Approach**: All functionality in a single `main.c` file for simplicity and rapid development. Can be refactored into modules later if needed.
+
+## 1. Project Overview
+
+### 1.1 Goals
+- Implement a production-ready Superball Thrower daemon in C
+- Leverage nostr_core_lib for all NOSTR protocol operations
+- Maintain protocol compatibility with the Node.js reference implementation
+- Provide better performance and lower resource usage than Node.js version
+- Support all SUPs (Superball Upgrade Proposals) 1-6
+
+### 1.2 Key Features
+- **Event Monitoring**: Subscribe to kind 22222 events across multiple relays
+- **NIP-44 Decryption**: Decrypt routing payloads using NIP-44
+- **Dual Payload Handling**: Support both routing and padding payload types
+- **Event Queue**: Delayed processing with configurable delays and jitter
+- **Relay Management**: Automatic authentication testing and capability detection
+- **Thrower Info Publishing**: SUP-06 compliant service announcements
+- **Configuration**: JSON-based configuration file support
+
+### 1.3 Why Single File?
+- **Simplicity**: Easier to understand the complete flow
+- **Faster Development**: No need to manage multiple files and headers
+- **Easier Debugging**: All code in one place
+- **Simpler Build**: Single compilation unit
+- **Can Refactor Later**: If file grows beyond ~2000 lines, split into modules
+
+## 2. Single-File Architecture
+
+### 2.1 File Organization in main.c
+
+```
+main.c (~1500-2000 lines)
+├── [1] Includes & Constants (50 lines)
+│   ├── System headers
+│   ├── nostr_core_lib headers
+│   └── Configuration constants
+│
+├── [2] Data Structures (150 lines)
+│   ├── superball_thrower_t (main context)
+│   ├── superball_config_t (configuration)
+│   ├── relay_config_t (relay settings)
+│   ├── routing_payload_t (routing instructions)
+│   ├── padding_payload_t (padding wrapper)
+│   ├── queue_item_t (queued event)
+│   └── event_queue_t (event queue)
+│
+├── [3] Forward Declarations (30 lines)
+│   └── All static function prototypes
+│
+├── [4] Global Variables (20 lines)
+│   ├── volatile sig_atomic_t running
+│   └── Global thrower instance
+│
+├── [5] Utility Functions (100 lines)
+│   ├── log_info(), log_error(), log_debug()
+│   ├── get_timestamp()
+│   ├── add_jitter()
+│   └── hex_to_bytes(), bytes_to_hex()
+│
+├── [6] Configuration Functions (200 lines)
+│   ├── config_load()
+│   ├── config_parse_thrower()
+│   ├── config_parse_relays()
+│   ├── config_validate()
+│   └── config_free()
+│
+├── [7] Crypto Functions (150 lines)
+│   ├── decrypt_nip44()
+│   ├── encrypt_nip44()
+│   ├── generate_padding()
+│   └── generate_ephemeral_keypair()
+│
+├── [8] Queue Functions (200 lines)
+│   ├── queue_create()
+│   ├── queue_add()
+│   ├── queue_get_ready()
+│   ├── queue_process_ready_items()
+│   └── queue_destroy()
+│
+├── [9] Relay Functions (150 lines)
+│   ├── relay_test_auth()
+│   ├── relay_publish_list()
+│   └── relay_init()
+│
+├── [10] Event Processing Functions (400 lines)
+│   ├── on_routing_event() [callback]
+│   ├── on_eose() [callback]
+│   ├── decrypt_payload()
+│   ├── parse_routing_payload()
+│   ├── parse_padding_payload()
+│   ├── validate_routing()
+│   ├── forward_to_next_thrower()
+│   ├── post_final_event()
+│   └── publish_callback()
+│
+├── [11] Thrower Info Functions (150 lines)
+│   ├── publish_thrower_info()
+│   ├── auto_publish_thread()
+│   └── stop_auto_publish()
+│
+└── [12] Main Functions (200 lines)
+    ├── signal_handler()
+    ├── thrower_create()
+    ├── thrower_start()
+    ├── thrower_stop()
+    ├── thrower_destroy()
+    └── main()
+
+Total: ~1800 lines
+```
+
+### 2.2 Dependency Structure
+
+```
+main.c
+└── Depends on:
+    └── nostr_core_lib/ (git submodule)
+        ├── nostr_core/nostr_core.h
+        ├── cjson/cJSON.h
+        └── libnostr_core.a (static library)
+```
+
+## 3. Core Data Structures
+
+```c
+// Main daemon context
+typedef struct {
+    superball_config_t* config;
+    nostr_relay_pool_t* pool;
+    event_queue_t* queue;
+    pthread_t auto_publish_thread;
+    unsigned char private_key[32];
+    unsigned char public_key[32];
+    int running;
+    int auto_publish_running;
+} superball_thrower_t;
+
+// Configuration structure
+typedef struct {
+    char* private_key_hex;
+    char* name;
+    char* description;
+    int max_delay;
+    int refresh_rate;
+    char* supported_sups;
+    char* software;
+    char* version;
+    relay_config_t* relays;
+    int relay_count;
+    int max_queue_size;
+} superball_config_t;
+
+// Relay configuration
+typedef struct {
+    char* url;
+    int read;
+    int write;
+    char* auth_status;  // "no-auth", "auth-required", "error", "unknown"
+} relay_config_t;
+
+// Routing payload (Type 1 - from builder)
+typedef struct {
+    cJSON* event;           // Inner event (encrypted or final)
+    char** relays;          // Target relay URLs
+    int relay_count;
+    int delay;              // Delay in seconds
+    char* next_hop_pubkey;  // NULL for final posting
+    char* audit_tag;        // Required audit tag
+    char* payment;          // Optional eCash token
+    int add_padding_bytes;  // Optional padding instruction
+} routing_payload_t;
+
+// Padding payload (Type 2 - from previous thrower)
+typedef struct {
+    cJSON* event;           // Still-encrypted inner event
+    char* padding;          // Padding data to discard
+} padding_payload_t;
+
+// Queue item
+typedef struct {
+    char event_id[65];
+    cJSON* wrapped_event;
+    routing_payload_t* routing;
+    time_t received_at;
+    time_t process_at;
+    char status[32];        // "queued", "processing", "completed", "failed"
+} queue_item_t;
+
+// Event queue
+typedef struct {
+    queue_item_t** items;
+    int count;
+    int capacity;
+    pthread_mutex_t mutex;
+} event_queue_t;
+
+// Payload type enum
+typedef enum {
+    PAYLOAD_ERROR = 0,
+    PAYLOAD_ROUTING = 1,    // Type 1: Routing instructions from builder
+    PAYLOAD_PADDING = 2     // Type 2: Padding wrapper from previous thrower
+} payload_type_t;
+```
+
+## 4. Key Implementation Patterns
+
+### 4.1 Event Monitoring Pattern
+```c
+static void start_monitoring(superball_thrower_t* thrower) {
+    // Create filter for kind 22222 with our pubkey
+    cJSON* filter = cJSON_CreateObject();
+    cJSON* kinds = cJSON_CreateArray();
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber(22222));
+    cJSON_AddItemToObject(filter, "kinds", kinds);
+    
+    cJSON* p_tags = cJSON_CreateArray();
+    char pubkey_hex[65];
+    nostr_bytes_to_hex(thrower->public_key, 32, pubkey_hex);
+    cJSON_AddItemToArray(p_tags, cJSON_CreateString(pubkey_hex));
+    cJSON_AddItemToObject(filter, "#p", p_tags);
+    
+    // Get relay URLs
+    const char** relay_urls = malloc(thrower->config->relay_count * sizeof(char*));
+    for (int i = 0; i < thrower->config->relay_count; i++) {
+        relay_urls[i] = thrower->config->relays[i].url;
+    }
+    
+    // Subscribe
+    nostr_relay_pool_subscribe(
+        thrower->pool,
+        relay_urls,
+        thrower->config->relay_count,
+        filter,
+        on_routing_event,  // Event callback
+        on_eose,           // EOSE callback
+        thrower,           // User data
+        0,                 // Don't close on EOSE
+        1,                 // Enable deduplication
+        NOSTR_POOL_EOSE_FULL_SET,
+        30,                // Relay timeout
+        60                 // EOSE timeout
+    );
+    
+    free(relay_urls);
+    cJSON_Delete(filter);
+}
+```
+
+### 4.2 Payload Decryption Pattern
+```c
+static payload_type_t decrypt_payload(superball_thrower_t* thrower, 
+                                     cJSON* event, 
+                                     void** payload_out) {
+    cJSON* content = cJSON_GetObjectItem(event, "content");
+    cJSON* pubkey = cJSON_GetObjectItem(event, "pubkey");
+    
+    if (!content || !pubkey) return PAYLOAD_ERROR;
+    
+    char decrypted[65536];  // 64KB buffer
+    int result = nostr_nip44_decrypt(
+        thrower->private_key,
+        cJSON_GetStringValue(pubkey),
+        cJSON_GetStringValue(content),
+        decrypted,
+        sizeof(decrypted)
+    );
+    
+    if (result != NOSTR_SUCCESS) return PAYLOAD_ERROR;
+    
+    cJSON* payload = cJSON_Parse(decrypted);
+    if (!payload) return PAYLOAD_ERROR;
+    
+    // Check payload type
+    if (cJSON_HasObjectItem(payload, "padding")) {
+        // Type 2: Padding payload - discard padding, decrypt inner event
+        *payload_out = parse_padding_payload(payload);
+        cJSON_Delete(payload);
+        return PAYLOAD_PADDING;
+    } else if (cJSON_HasObjectItem(payload, "routing")) {
+        // Type 1: Routing payload - process routing instructions
+        *payload_out = parse_routing_payload(payload);
+        cJSON_Delete(payload);
+        return PAYLOAD_ROUTING;
+    }
+    
+    cJSON_Delete(payload);
+    return PAYLOAD_ERROR;
+}
+```
+
+### 4.3 Double Decryption Pattern
+```c
+static void on_routing_event(cJSON* event, const char* relay_url, void* user_data) {
+    superball_thrower_t* thrower = (superball_thrower_t*)user_data;
+    
+    log_info("Received routing event from %s", relay_url);
+    
+    // First decryption
+    void* payload = NULL;
+    payload_type_t type = decrypt_payload(thrower, event, &payload);
+    
+    if (type == PAYLOAD_PADDING) {
+        // Type 2: Padding payload - perform second decryption
+        padding_payload_t* padding_payload = (padding_payload_t*)payload;
+        log_info("Detected padding payload, discarding padding and performing second decryption");
+        
+        // Second decryption to get routing instructions
+        void* routing_payload = NULL;
+        payload_type_t inner_type = decrypt_payload(thrower, padding_payload->event, &routing_payload);
+        
+        if (inner_type == PAYLOAD_ROUTING) {
+            // Process the routing instructions
+            routing_payload_t* routing = (routing_payload_t*)routing_payload;
+            queue_add(thrower->queue, create_queue_item(padding_payload->event, routing));
+        }
+        
+        free_padding_payload(padding_payload);
+    } else if (type == PAYLOAD_ROUTING) {
+        // Type 1: Routing payload - process directly
+        log_info("Detected routing payload, processing directly");
+        routing_payload_t* routing = (routing_payload_t*)payload;
+        queue_add(thrower->queue, create_queue_item(event, routing));
+    }
+}
+```
+
+## 5. nostr_core_lib API Usage
+
+| Functionality | Function | Usage in main.c |
+|---------------|----------|-----------------|
+| **Pool Management** | `nostr_relay_pool_create()` | `thrower_create()` |
+| | `nostr_relay_pool_add_relay()` | `relay_init()` |
+| | `nostr_relay_pool_destroy()` | `thrower_destroy()` |
+| **Subscriptions** | `nostr_relay_pool_subscribe()` | `start_monitoring()` |
+| | `nostr_relay_pool_poll()` | `main()` event loop |
+| **Publishing** | `nostr_relay_pool_publish_async()` | `forward_to_next_thrower()`, `post_final_event()` |
+| **NIP-44** | `nostr_nip44_encrypt()` | `encrypt_nip44()` |
+| | `nostr_nip44_decrypt()` | `decrypt_nip44()` |
+| **Keys** | `nostr_generate_keypair()` | `generate_ephemeral_keypair()` |
+| **Events** | `nostr_create_and_sign_event()` | `forward_to_next_thrower()`, `publish_thrower_info()` |
+| **Utilities** | `nostr_bytes_to_hex()` | Various functions |
+| | `nostr_hex_to_bytes()` | `config_load()` |
+
+## 6. Simplified File Structure
+
+```
+super_ball_thrower/
+├── main.c                       # Complete implementation (~1800 lines)
+├── config.example.json          # Example configuration
+├── config.json                  # User configuration (gitignored)
+├── Makefile                     # Build system
+├── README.md                    # Documentation
+├── .gitignore                   # Git ignore rules
+├── nostr_core_lib/              # Git submodule
+└── plans/
+    └── superball_thrower_c_architecture.md
+```
+
+## 7. Build System
+
+### 7.1 Makefile
+```makefile
+CC = gcc
+CFLAGS = -Wall -Wextra -O2 -I./nostr_core_lib/nostr_core -I./nostr_core_lib/cjson
+LDFLAGS = -L./nostr_core_lib -lnostr_core -lssl -lcrypto -lcurl -lsecp256k1 -lm -lpthread
+
+TARGET = superball_thrower
+SOURCE = main.c
+
+all: nostr_core_lib $(TARGET)
+
+nostr_core_lib:
+	@echo "Building nostr_core_lib..."
+	cd nostr_core_lib && ./build.sh lib
+
+$(TARGET): $(SOURCE)
+	$(CC) $(CFLAGS) $(SOURCE) -o $(TARGET) $(LDFLAGS)
+
+clean:
+	rm -f $(TARGET)
+
+distclean: clean
+	cd nostr_core_lib && make clean
+
+install: $(TARGET)
+	install -m 755 $(TARGET) /usr/local/bin/
+
+.PHONY: all clean distclean install nostr_core_lib
+```
+
+### 7.2 Build Commands
+```bash
+# Build everything
+make
+
+# Clean build artifacts
+make clean
+
+# Clean everything including nostr_core_lib
+make distclean
+
+# Install to system
+sudo make install
+```
+
+## 8. Configuration File Format
+
+```json
+{
+  "thrower": {
+    "privateKey": "hex_private_key_here",
+    "name": "My C Superball Thrower",
+    "description": "High-performance C implementation",
+    "maxDelay": 86460,
+    "refreshRate": 300,
+    "supportedSups": "1,2,3,4,5,6",
+    "software": "https://git.laantungir.net/laantungir/super_ball_thrower.git",
+    "version": "1.0.0"
+  },
+  "relays": [
+    {
+      "url": "wss://relay.laantungir.net",
+      "read": true,
+      "write": true
+    },
+    {
+      "url": "wss://relay.damus.io",
+      "read": true,
+      "write": false
+    }
+  ],
+  "daemon": {
+    "logLevel": "info",
+    "maxQueueSize": 1000
+  }
+}
+```
+
+## 9. Implementation Phases
+
+### Phase 1: Core Implementation (Days 1-3)
+- [x] Architecture design
+- [ ] Create main.c with all sections:
+  - [ ] Includes, constants, data structures
+  - [ ] Configuration loading and parsing
+  - [ ] Crypto wrapper functions
+  - [ ] Event queue implementation
+  - [ ] Event processing logic
+  - [ ] Relay management
+  - [ ] Thrower info publishing
+  - [ ] Main function and event loop
+- [ ] Create Makefile
+- [ ] Create config.example.json
+
+### Phase 2: Testing & Refinement (Days 4-5)
+- [ ] Basic functionality testing
+- [ ] Integration test with Node.js thrower
+- [ ] Bug fixes and optimization
+- [ ] Documentation
+- [ ] Usage examples
+
+### Phase 3: Optional Enhancements (Future)
+- [ ] Split into modules if file becomes too large (>2000 lines)
+- [ ] Add systemd service file
+- [ ] Add installation script
+- [ ] Performance profiling
+- [ ] Additional logging options
+
+## 10. Success Criteria
+
+1. **Protocol Compliance**: Pass all SUP-01 through SUP-06 requirements
+2. **Interoperability**: Successfully route events with Node.js throwers
+3. **Performance**: Handle 100+ events/second with <100MB RAM
+4. **Reliability**: 99.9% uptime in 24-hour test
+5. **Code Quality**: Clean, well-commented, single-file implementation
+
+## 11. Advantages of Single-File Approach
+
+1. **Simplicity**: Everything in one place, easy to understand
+2. **Fast Compilation**: Single compilation unit
+3. **Easy Debugging**: No jumping between files
+4. **Portable**: Just copy main.c and build
+5. **No Header Management**: No .h files to maintain
+6. **Static Functions**: All implementation details are private
+7. **Can Refactor Later**: Easy to split if needed
+
+## 12. When to Refactor into Modules
+
+Consider splitting into modules if:
+- File exceeds 2000 lines
+- Multiple developers working on different features
+- Need to reuse components in other projects
+- Testing individual components separately becomes important
+
+## 13. Next Steps
+
+1. ✅ Architecture design complete
+2. Switch to Code mode
+3. Implement main.c with all functionality
+4. Create Makefile and config.example.json
+5. Test with Node.js reference implementation
+6. Document usage and deployment
+
+---
+
+**Document Version**: 2.0 (Simplified)  
+**Last Updated**: 2025-12-10  
+**Author**: Roo (Architect Mode)  
+**Approach**: Single-file monolithic design for rapid development