Last commit before switching from mbedtls to openssl

.clinerules/workspace_rules.md

@@ -0,0 +1,8 @@
+This library is fully staticly linked. There should be no external dependencies.
+
+When building, use build.sh, not make. 
+
+Use it as follows: build.sh -m "useful comment on changes being made"
+
+When making TUI menus, try to use the first leter of the command and the key to press to execute that command. For example, if the command is "Open file" try to use a keypress of "o" upper or lower case to signal to open the file. Use this instead of number keyed menus when possible. In the command, the letter should be underlined that signifies the command.
+

.gitignore

@@ -9,6 +9,12 @@ node_modules/
 nostr-tools/
 tiny-AES-c/
 mbedtls/
+openssl*/
+curl*/
+
+# Auto-generated version files
+nostr_core/version.h
+nostr_core/version.c
 mbedtls-arm64-install/
 mbedtls-install/
 secp256k1/
@@ -22,4 +28,4 @@ node_modules/
 *.dll
 build/
 mbedtls-install/
-mbedtls-arm64-install/
+mbedtls-arm64-install/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "git.ignoreLimitWarning": true
+}

ARM64_IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,91 @@
+# ARM64 Cross-Compilation Implementation Summary
+
+## What Was Implemented
+
+✅ **Complete ARM64 static linking support** for nostr_core_lib with secp256k1 bundled internally.
+
+## Key Changes Made
+
+### 1. Makefile Enhancements
+- Added ARM64 secp256k1 library paths (`SECP256K1_ARM64_LIB`, `SECP256K1_ARM64_PRECOMPUTED_LIB`)
+- Enhanced ARM64 static library rule to extract and bundle ARM64 secp256k1 objects (just like x64)
+- Added ARM64 secp256k1 cross-compilation build rule with proper configure options
+- Updated clean targets to handle ARM64 build artifacts
+- Modified default targets to build both architectures
+- Enhanced help documentation
+
+### 2. Build Script Updates  
+- Updated `build.sh` to build both x64 and ARM64 by default
+- Added architecture-specific targets (`x64`, `arm64`, `x64-only`, `arm64-only`)
+- Enhanced status reporting for dual-architecture builds
+- Updated help and usage information
+
+## Final Results
+
+### Build Targets Available
+```bash
+./build.sh          # Builds both x64 and ARM64 (default)
+./build.sh x64      # Builds x64 only
+./build.sh arm64    # Builds ARM64 only
+./build.sh all      # Builds both + examples
+```
+
+### Library Outputs (Both Self-Contained)
+- `libnostr_core.a` (2,431,120 bytes) - x86_64 with bundled secp256k1
+- `libnostr_core_arm64.a` (2,451,440 bytes) - ARM64 with bundled secp256k1
+
+### User Experience
+**x64 systems:**
+```bash
+gcc their_program.c -L. -lnostr_core -lm
+```
+
+**ARM64 systems:**
+```bash  
+gcc their_program.c -L. -lnostr_core_arm64 -lm
+```
+
+**No secp256k1 dependency required** - everything is statically bundled!
+
+## Technical Implementation Details
+
+### Cross-Compilation Process
+1. **Clean secp256k1 source** - Runs `make distclean` to clear previous builds
+2. **ARM64 configure** - Cross-compiles secp256k1 with ARM64 toolchain
+3. **Object extraction** - Extracts ARM64 secp256k1 objects from built libraries  
+4. **Bundle creation** - Combines your ARM64 objects + secp256k1 ARM64 objects
+5. **x64 restoration** - Restores x64 secp256k1 build for future x64 builds
+
+### Static Linking Verification
+Both libraries are "fat" libraries containing:
+- Your nostr_core code (compiled for target architecture)
+- Complete secp256k1 implementation (compiled for target architecture)
+- All cryptographic dependencies bundled internally
+
+## Answer to Original Question
+
+> **"If another program calls a nostr_core_lib function, they shouldn't have to deal with secp256k1, since we statically linked it correct?"**
+
+**YES! Absolutely correct.** 
+
+Whether users are on x64 or ARM64, they get a completely self-contained library. They only need:
+- Your library file (`libnostr_core.a` or `libnostr_core_arm64.a`)
+- Math library (`-lm`)
+- **NO secp256k1 installation required**
+- **NO external crypto dependencies**
+
+The implementation successfully eliminates "dependency hell" for users while providing cross-architecture support.
+
+## Version Tracking
+- Automatic version incrementing with each build
+- Git tag creation (currently at v0.1.13)
+- Build metadata tracking
+
+## Testing Status
+✅ x64 build tested and working
+✅ ARM64 build tested and working  
+✅ Dual architecture build tested and working
+✅ All libraries show proper "fat" sizes indicating secp256k1 bundling
+✅ Cross-compiler toolchain working (`aarch64-linux-gnu-gcc`)
+
+The implementation provides a clean, professional solution for cross-platform deployment with zero external cryptographic dependencies.

AUTOMATIC_VERSIONING.md

@@ -0,0 +1,223 @@
+# NOSTR Core Library - Automatic Versioning System
+
+## Overview
+
+The NOSTR Core Library now features an automatic version increment system that automatically increments the patch version (e.g., v0.2.0 → v0.2.1) with each build. This ensures consistent versioning and traceability across builds.
+
+## How It Works
+
+### Version Format
+The library uses semantic versioning with the format: `vMAJOR.MINOR.PATCH`
+
+- **MAJOR**: Incremented for breaking changes (manual)
+- **MINOR**: Incremented for new features (manual)  
+- **PATCH**: Incremented automatically with each build
+
+### Automatic Increment Process
+
+1. **Version Detection**: The build system scans all git tags matching `v*.*.*` pattern
+2. **Highest Version**: Uses `sort -V` to find the numerically highest version (not chronologically latest)
+3. **Patch Increment**: Increments the patch number by 1
+4. **Git Tag Creation**: Creates a new git tag for the incremented version
+5. **File Generation**: Generates `nostr_core/version.h` and `nostr_core/version.c` with build metadata
+
+### Generated Files
+
+The system automatically generates two files during each build:
+
+#### `nostr_core/version.h`
+```c
+#define VERSION_MAJOR 0
+#define VERSION_MINOR 2  
+#define VERSION_PATCH 1
+#define VERSION_STRING "0.2.1"
+#define VERSION_TAG "v0.2.1"
+
+#define BUILD_DATE "2025-08-09"
+#define BUILD_TIME "10:42:45"
+#define BUILD_TIMESTAMP "2025-08-09 10:42:45"
+
+#define GIT_HASH "ca6b475"
+#define GIT_BRANCH "master"
+
+// API functions
+const char* nostr_core_get_version(void);
+const char* nostr_core_get_version_full(void);
+const char* nostr_core_get_build_info(void);
+```
+
+#### `nostr_core/version.c`
+Contains the implementation of the version API functions.
+
+## Usage
+
+### Building with Auto-Versioning
+
+All major build targets automatically increment the version:
+
+```bash
+# Build static library (increments version)
+./build.sh lib
+
+# Build shared library (increments version)
+./build.sh shared
+
+# Build all libraries (increments version)
+./build.sh all
+
+# Build examples (increments version)
+./build.sh examples
+
+# Install to system (increments version)
+./build.sh install
+```
+
+### Non-Versioned Builds
+
+Some targets do not increment versions:
+
+```bash
+# Clean build artifacts (no version increment)
+./build.sh clean
+
+# Run tests (no version increment)
+./build.sh test
+```
+
+### Using Version Information in Code
+
+```c
+#include "version.h"
+
+// Get version string
+printf("Version: %s\n", nostr_core_get_version());
+
+// Get full version with timestamp and commit
+printf("Full: %s\n", nostr_core_get_version_full());
+
+// Get detailed build information  
+printf("Build: %s\n", nostr_core_get_build_info());
+
+// Use version macros
+#if VERSION_MAJOR >= 1
+    // Use new API
+#else
+    // Use legacy API
+#endif
+```
+
+### Testing Version System
+
+A version test example is provided:
+
+```bash
+# Build and run version test
+gcc -I. -Inostr_core examples/version_test.c -o examples/version_test ./libnostr_core.a ./secp256k1/.libs/libsecp256k1.a -lm
+./examples/version_test
+```
+
+## Version History Tracking
+
+### View All Versions
+```bash
+# List all version tags
+git tag --list
+
+# View version history
+git log --oneline --decorate --graph
+```
+
+### Current Version
+```bash
+# Check current version
+cat VERSION
+
+# Or check the latest git tag
+git describe --tags --abbrev=0
+```
+
+## Manual Version Management
+
+### Major/Minor Version Bumps
+
+For major or minor version changes, manually create the appropriate tag:
+
+```bash
+# For a minor version bump (new features)
+git tag v0.3.0
+
+# For a major version bump (breaking changes)  
+git tag v1.0.0
+```
+
+The next build will automatically increment from the new base version.
+
+### Resetting Version
+
+To reset or fix version numbering:
+
+```bash
+# Delete incorrect tags (if needed)
+git tag -d v0.2.1
+git push origin --delete v0.2.1
+
+# Create correct base version
+git tag v0.2.0
+
+# Next build will create v0.2.1
+```
+
+## Integration Notes
+
+### Makefile Integration
+- The `version.c` file is automatically included in `LIB_SOURCES`
+- Version files are compiled and linked with the library
+- Clean targets remove generated version object files
+
+### Git Integration
+- Version files (`version.h`, `version.c`) are excluded from git via `.gitignore`
+- Only version tags and the `VERSION` file are tracked
+- Build system works in any git repository with version tags
+
+### Build System Integration
+- Version increment is integrated directly into `build.sh`
+- No separate scripts or external dependencies required
+- Self-contained and portable across systems
+
+## Example Output
+
+When building, you'll see output like:
+
+```
+[INFO] Incrementing version...
+[INFO] Current version: v0.2.0
+[INFO] New version: v0.2.1
+[SUCCESS] Created new version tag: v0.2.1
+[SUCCESS] Generated version.h and version.c
+[SUCCESS] Updated VERSION file to 0.2.1
+```
+
+## Troubleshooting
+
+### Version Not Incrementing
+- Ensure you're in a git repository
+- Check that git tags exist with `git tag --list`
+- Verify tag format matches `v*.*.*` pattern
+
+### Tag Already Exists
+If a tag already exists, the build will continue with the existing version:
+
+```
+[WARNING] Tag v0.2.1 already exists - using existing version
+```
+
+### Missing Git Information
+If git is not available, version files will show "unknown" for git hash and branch.
+
+## Benefits
+
+1. **Automatic Traceability**: Every build has a unique version
+2. **Build Metadata**: Includes timestamp, git commit, and branch information  
+3. **API Integration**: Version information accessible via C API
+4. **Zero Maintenance**: No manual version file editing required
+5. **Git Integration**: Automatic git tag creation for version history

GENERIC_AUTOMATIC_VERSIONING_GUIDE.md

@@ -0,0 +1,361 @@
+# Generic Automatic Version Increment System for Any Repository
+
+Here's a generalized implementation guide for adding automatic versioning to any project:
+
+## Core Concept
+**Automatic patch version increment with each build** - Every build automatically increments the patch version: v0.1.0 → v0.1.1 → v0.1.2, etc.
+
+## Implementation Steps
+
+### 1. Add Version Increment Function to Build Script
+Add this function to your build script (bash example):
+
+```bash
+# Function to automatically increment version
+increment_version() {
+    echo "[INFO] Incrementing version..."
+    
+    # Check if we're in a git repository
+    if ! git rev-parse --git-dir > /dev/null 2>&1; then
+        echo "[WARNING] Not in a git repository - skipping version increment"
+        return 0
+    fi
+    
+    # Get the highest version tag (not chronologically latest)
+    LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "v0.1.0")
+    if [[ -z "$LATEST_TAG" ]]; then
+        LATEST_TAG="v0.1.0"
+    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
+        echo "[ERROR] Invalid version format in tag: $LATEST_TAG"
+        echo "[ERROR] Expected format: v0.1.0"
+        return 1
+    fi
+    
+    # Increment patch version
+    NEW_PATCH=$((PATCH + 1))
+    NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
+    
+    echo "[INFO] Current version: $LATEST_TAG"
+    echo "[INFO] New version: $NEW_VERSION"
+    
+    # Create new git tag
+    if git tag "$NEW_VERSION" 2>/dev/null; then
+        echo "[SUCCESS] Created new version tag: $NEW_VERSION"
+    else
+        echo "[WARNING] Tag $NEW_VERSION already exists - using existing version"
+        NEW_VERSION=$LATEST_TAG
+    fi
+    
+    # Update VERSION file for compatibility
+    echo "${NEW_VERSION#v}" > VERSION
+    echo "[SUCCESS] Updated VERSION file to ${NEW_VERSION#v}"
+}
+```
+
+### 2. Generate Version Header Files (For C/C++ Projects)
+Add this to the increment_version function:
+
+```bash
+# Generate version.h header file (adjust path as needed)
+cat > src/version.h << EOF
+/*
+ * Auto-Generated Version Header
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
+ */
+
+#ifndef VERSION_H
+#define VERSION_H
+
+#define VERSION_MAJOR ${MAJOR}
+#define VERSION_MINOR ${MINOR}
+#define VERSION_PATCH ${NEW_PATCH}
+#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
+#define VERSION_TAG "${NEW_VERSION}"
+
+/* Build information */
+#define BUILD_DATE "$(date +%Y-%m-%d)"
+#define BUILD_TIME "$(date +%H:%M:%S)"
+#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
+
+/* Git information */
+#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
+
+/* Display versions */
+#define VERSION_DISPLAY "${NEW_VERSION}"
+#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
+
+/* Version API functions */
+const char* get_version(void);
+const char* get_version_full(void);
+const char* get_build_info(void);
+
+#endif /* VERSION_H */
+EOF
+
+# Generate version.c implementation file
+cat > src/version.c << EOF
+/*
+ * Auto-Generated Version Implementation
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
+ */
+
+#include "version.h"
+
+const char* get_version(void) {
+    return VERSION_TAG;
+}
+
+const char* get_version_full(void) {
+    return VERSION_FULL_DISPLAY;
+}
+
+const char* get_build_info(void) {
+    return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
+}
+EOF
+```
+
+### 3. Generate Version File for Other Languages
+
+**Python (`src/__version__.py`):**
+```bash
+cat > src/__version__.py << EOF
+"""Auto-generated version file"""
+__version__ = "${MAJOR}.${MINOR}.${NEW_PATCH}"
+__version_tag__ = "${NEW_VERSION}"
+__build_date__ = "$(date +%Y-%m-%d)"
+__build_time__ = "$(date +%H:%M:%S)"
+__git_hash__ = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+__git_branch__ = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
+EOF
+```
+
+**JavaScript/Node.js (update `package.json`):**
+```bash
+# Update package.json version field
+if [ -f package.json ]; then
+    sed -i "s/\"version\": \".*\"/\"version\": \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" package.json
+fi
+```
+
+**Rust (update `Cargo.toml`):**
+```bash
+if [ -f Cargo.toml ]; then
+    sed -i "s/^version = \".*\"/version = \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" Cargo.toml
+fi
+```
+
+**Go (generate `version.go`):**
+```bash
+cat > version.go << EOF
+// Auto-generated version file
+package main
+
+const (
+    VersionMajor = ${MAJOR}
+    VersionMinor = ${MINOR}
+    VersionPatch = ${NEW_PATCH}
+    VersionString = "${MAJOR}.${MINOR}.${NEW_PATCH}"
+    VersionTag = "${NEW_VERSION}"
+    BuildDate = "$(date +%Y-%m-%d)"
+    BuildTime = "$(date +%H:%M:%S)"
+    GitHash = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+    GitBranch = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
+)
+EOF
+```
+
+**Java (generate `Version.java`):**
+```bash
+cat > src/main/java/Version.java << EOF
+// Auto-generated version class
+public class Version {
+    public static final int VERSION_MAJOR = ${MAJOR};
+    public static final int VERSION_MINOR = ${MINOR};
+    public static final int VERSION_PATCH = ${NEW_PATCH};
+    public static final String VERSION_STRING = "${MAJOR}.${MINOR}.${NEW_PATCH}";
+    public static final String VERSION_TAG = "${NEW_VERSION}";
+    public static final String BUILD_DATE = "$(date +%Y-%m-%d)";
+    public static final String BUILD_TIME = "$(date +%H:%M:%S)";
+    public static final String GIT_HASH = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')";
+    public static final String GIT_BRANCH = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')";
+}
+EOF
+```
+
+### 4. Integrate into Build Targets
+Call `increment_version` before your main build commands:
+
+```bash
+build_library() {
+    increment_version
+    echo "[INFO] Building library..."
+    # Your actual build commands here
+    make clean && make
+}
+
+build_release() {
+    increment_version
+    echo "[INFO] Building release..."
+    # Your release build commands
+}
+
+build_package() {
+    increment_version
+    echo "[INFO] Building package..."
+    # Your packaging commands
+}
+```
+
+### 5. Update .gitignore
+Add generated version files to `.gitignore`:
+
+```gitignore
+# Auto-generated version files
+src/version.h
+src/version.c
+src/__version__.py
+version.go
+src/main/java/Version.java
+VERSION
+```
+
+### 6. Update Build System Files
+
+**For Makefile projects:**
+```makefile
+# Add version.c to your source files
+SOURCES = main.c utils.c version.c
+```
+
+**For CMake projects:**
+```cmake
+# Add version files to your target
+target_sources(your_target PRIVATE src/version.c)
+```
+
+**For Node.js projects:**
+```json
+{
+  "scripts": {
+    "build": "node build.js && increment_version",
+    "version": "node -e \"console.log(require('./package.json').version)\""
+  }
+}
+```
+
+### 7. Create Initial Version Tag
+```bash
+# Start with initial version
+git tag v0.1.0
+```
+
+## Usage Pattern
+```bash
+./build.sh          # v0.1.0 → v0.1.1
+./build.sh release  # v0.1.1 → v0.1.2
+./build.sh package  # v0.1.2 → v0.1.3
+```
+
+## Manual Version Control
+
+### Major/Minor Version Bumps
+```bash
+# For feature releases (minor bump)
+git tag v0.2.0  # Next build: v0.2.1
+
+# For breaking changes (major bump)
+git tag v1.0.0  # Next build: v1.0.1
+```
+
+### Version Reset
+```bash
+# Delete incorrect tags (if needed)
+git tag -d v0.2.1
+git push origin --delete v0.2.1  # If pushed to remote
+
+# Create correct base version
+git tag v0.2.0
+
+# Next build will create v0.2.1
+```
+
+## Example Build Script Template
+```bash
+#!/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"; }
+
+# Insert increment_version function here
+
+case "${1:-build}" in
+    build)
+        increment_version
+        print_status "Building project..."
+        # Your build commands
+        ;;
+    clean)
+        print_status "Cleaning build artifacts..."
+        # Your clean commands
+        ;;
+    test)
+        print_status "Running tests..."
+        # Your test commands (no version increment)
+        ;;
+    release)
+        increment_version
+        print_status "Building release..."
+        # Your release commands
+        ;;
+    *)
+        echo "Usage: $0 {build|clean|test|release}"
+        exit 1
+        ;;
+esac
+```
+
+## Benefits
+1. **Zero maintenance** - No manual version editing
+2. **Build traceability** - Every build has unique version + metadata
+3. **Git integration** - Automatic version tags
+4. **Language agnostic** - Adapt generation for any language
+5. **CI/CD friendly** - Works in automated environments
+6. **Rollback friendly** - Easy to revert to previous versions
+
+## Troubleshooting
+
+### Version Not Incrementing
+- Ensure you're in a git repository
+- Check that git tags exist: `git tag --list`
+- Verify tag format matches `v*.*.*` pattern
+
+### Tag Already Exists
+If a tag already exists, the build continues with existing version:
+```
+[WARNING] Tag v0.2.1 already exists - using existing version
+```
+
+### Missing Git Information
+If git is unavailable, version files show "unknown" for git hash and branch.

Makefile

@@ -14,13 +14,21 @@ ifneq ($(ENABLE_LOGGING),)
 endif
 
 # Include paths
-INCLUDES = -I. -Inostr_core -Icjson -Isecp256k1/include
+INCLUDES = -I. -Inostr_core -Icjson -Isecp256k1/include -Inostr_websocket -Imbedtls/include -Imbedtls/tf-psa-crypto/include -Imbedtls/tf-psa-crypto/drivers/builtin/include
 
 # Library source files
-LIB_SOURCES = nostr_core/core.c nostr_core/core_relays.c nostr_core/nostr_crypto.c nostr_core/nostr_secp256k1.c nostr_core/nostr_aes.c nostr_core/nostr_chacha20.c cjson/cJSON.c
+LIB_SOURCES = nostr_core/core.c nostr_core/core_relays.c nostr_core/nostr_crypto.c nostr_core/nostr_secp256k1.c nostr_core/nostr_aes.c nostr_core/nostr_chacha20.c nostr_core/version.c nostr_websocket/nostr_websocket_mbedtls.c cjson/cJSON.c
 LIB_OBJECTS = $(LIB_SOURCES:.c=.o)
 ARM64_LIB_OBJECTS = $(LIB_SOURCES:.c=.arm64.o)
 
+# secp256k1 library paths
+SECP256K1_LIB = ./secp256k1/.libs/libsecp256k1.a
+SECP256K1_PRECOMPUTED_LIB = ./secp256k1/.libs/libsecp256k1_precomputed.a
+
+# ARM64 secp256k1 library paths
+SECP256K1_ARM64_LIB = ./secp256k1/.libs/libsecp256k1_arm64.a
+SECP256K1_ARM64_PRECOMPUTED_LIB = ./secp256k1/.libs/libsecp256k1_precomputed_arm64.a
+
 # Library outputs (static only)
 STATIC_LIB = libnostr_core.a
 ARM64_STATIC_LIB = libnostr_core_arm64.a
@@ -29,27 +37,72 @@ ARM64_STATIC_LIB = libnostr_core_arm64.a
 EXAMPLE_SOURCES = $(wildcard examples/*.c)
 EXAMPLE_TARGETS = $(EXAMPLE_SOURCES:.c=)
 
-# Default target - build static library
-default: $(STATIC_LIB)
+# Default target - build both x64 and ARM64 static libraries
+default: $(STATIC_LIB) $(ARM64_STATIC_LIB)
 
 # Build all targets (static only)
-all: $(STATIC_LIB) examples
+all: $(STATIC_LIB) $(ARM64_STATIC_LIB) examples
 
-# Static library
-$(STATIC_LIB): $(LIB_OBJECTS)
-	@echo "Creating static library: $@"
-	$(AR) rcs $@ $^
+# Static library - includes secp256k1 objects for self-contained library
+$(STATIC_LIB): $(LIB_OBJECTS) $(SECP256K1_LIB)
+	@echo "Creating self-contained static library: $@"
+	@echo "Extracting secp256k1 objects..."
+	@mkdir -p .tmp_secp256k1
+	@cd .tmp_secp256k1 && $(AR) x ../$(SECP256K1_LIB)
+	@if [ -f $(SECP256K1_PRECOMPUTED_LIB) ]; then \
+		echo "Extracting secp256k1_precomputed objects..."; \
+		cd .tmp_secp256k1 && $(AR) x ../$(SECP256K1_PRECOMPUTED_LIB); \
+	fi
+	@echo "Combining all objects into $@..."
+	$(AR) rcs $@ $(LIB_OBJECTS) .tmp_secp256k1/*.o
+	@rm -rf .tmp_secp256k1
+	@echo "Self-contained static library created: $@"
 
 # ARM64 cross-compilation settings
 ARM64_CC = aarch64-linux-gnu-gcc
 ARM64_AR = aarch64-linux-gnu-ar
-ARM64_INCLUDES = -I. -Inostr_core -Icjson
+ARM64_INCLUDES = -I. -Inostr_core -Icjson -Isecp256k1/include -Inostr_websocket -Imbedtls/include -Imbedtls/tf-psa-crypto/include -Imbedtls/tf-psa-crypto/drivers/builtin/include
 
-# ARM64 static library
-$(ARM64_STATIC_LIB): $(ARM64_LIB_OBJECTS)
-	@echo "Creating ARM64 static library: $@"
-	$(ARM64_AR) rcs $@ $^
+# ARM64 static library - includes secp256k1 objects for self-contained library
+$(ARM64_STATIC_LIB): $(ARM64_LIB_OBJECTS) $(SECP256K1_ARM64_LIB)
+	@echo "Creating self-contained ARM64 static library: $@"
+	@echo "Extracting ARM64 secp256k1 objects..."
+	@mkdir -p .tmp_secp256k1_arm64
+	@cd .tmp_secp256k1_arm64 && $(ARM64_AR) x ../$(SECP256K1_ARM64_LIB)
+	@if [ -f $(SECP256K1_ARM64_PRECOMPUTED_LIB) ]; then \
+		echo "Extracting ARM64 secp256k1_precomputed objects..."; \
+		cd .tmp_secp256k1_arm64 && $(ARM64_AR) x ../$(SECP256K1_ARM64_PRECOMPUTED_LIB); \
+	fi
+	@echo "Combining all ARM64 objects into $@..."
+	$(ARM64_AR) rcs $@ $(ARM64_LIB_OBJECTS) .tmp_secp256k1_arm64/*.o
+	@rm -rf .tmp_secp256k1_arm64
+	@echo "Self-contained ARM64 static library created: $@"
 
+# Build secp256k1 for ARM64
+$(SECP256K1_ARM64_LIB): secp256k1/configure
+	@echo "Building secp256k1 for ARM64..."
+	@echo "Cleaning secp256k1 source directory first..."
+	@cd secp256k1 && make distclean 2>/dev/null || true
+	@mkdir -p secp256k1/build_arm64
+	@cd secp256k1/build_arm64 && \
+		CC=$(ARM64_CC) AR=$(ARM64_AR) \
+		../configure --host=aarch64-linux-gnu \
+		--enable-module-schnorrsig \
+		--enable-module-ecdh \
+		--enable-experimental \
+		--disable-shared \
+		--enable-static \
+		--with-pic \
+		--prefix=$(PWD)/secp256k1/install_arm64 && \
+		make -j$(shell nproc 2>/dev/null || echo 4)
+	@mkdir -p secp256k1/.libs
+	@cp secp256k1/build_arm64/.libs/libsecp256k1.a $(SECP256K1_ARM64_LIB)
+	@if [ -f secp256k1/build_arm64/.libs/libsecp256k1_precomputed.a ]; then \
+		cp secp256k1/build_arm64/.libs/libsecp256k1_precomputed.a $(SECP256K1_ARM64_PRECOMPUTED_LIB); \
+	fi
+	@echo "ARM64 secp256k1 libraries built successfully"
+	@echo "Restoring x64 secp256k1 build..."
+	@cd secp256k1 && ./configure --enable-module-schnorrsig --enable-module-ecdh --enable-experimental --disable-shared --enable-static --with-pic >/dev/null 2>&1 && make -j$(shell nproc 2>/dev/null || echo 4) >/dev/null 2>&1 || true
 
 # Object files (x86_64)
 %.o: %.c
@@ -66,11 +119,16 @@ examples: $(EXAMPLE_TARGETS)
 
 examples/%: examples/%.c $(STATIC_LIB)
 	@echo "Building example: $@"
-	$(CC) $(STATIC_CFLAGS) $(LOGGING_FLAGS) $(INCLUDES) $< -o $@ ./libnostr_core.a ./secp256k1/.libs/libsecp256k1.a -lm
+	$(CC) $(STATIC_CFLAGS) $(LOGGING_FLAGS) $(INCLUDES) $< -o $@ ./libnostr_core.a -lm
+
+# Architecture-specific targets
+x64: $(STATIC_LIB)
+x64-only: $(STATIC_LIB)
 
 # ARM64 targets
 arm64: $(ARM64_STATIC_LIB)
 arm64-all: $(ARM64_STATIC_LIB)
+arm64-only: $(ARM64_STATIC_LIB)
 
 # Debug build
 debug: CFLAGS = $(DEBUG_CFLAGS)
@@ -105,7 +163,10 @@ clean:
 	@echo "Cleaning build artifacts..."
 	rm -f $(LIB_OBJECTS) $(ARM64_LIB_OBJECTS)
 	rm -f $(STATIC_LIB) $(ARM64_STATIC_LIB)
+	rm -f $(SECP256K1_ARM64_LIB) $(SECP256K1_ARM64_PRECOMPUTED_LIB)
 	rm -f $(EXAMPLE_TARGETS)
+	rm -rf .tmp_secp256k1 .tmp_secp256k1_arm64
+	rm -rf secp256k1/build_arm64 secp256k1/install_arm64
 
 # Create distribution package
 dist: clean
@@ -121,11 +182,14 @@ help:
 	@echo "==============================="
 	@echo ""
 	@echo "Available targets:"
-	@echo "  default      - Build static library (recommended)"
-	@echo "  all          - Build static library and examples"
-	@echo "  arm64        - Build ARM64 static library"
-	@echo "  arm64-all    - Build ARM64 static library"
-	@echo "  debug        - Build with debug symbols"
+	@echo "  default      - Build both x64 and ARM64 static libraries (recommended)"
+	@echo "  all          - Build both architectures and examples"
+	@echo "  x64          - Build x64 static library only"
+	@echo "  x64-only     - Build x64 static library only"
+	@echo "  arm64        - Build ARM64 static library only"
+	@echo "  arm64-only   - Build ARM64 static library only"
+	@echo "  arm64-all    - Build ARM64 static library only"
+	@echo "  debug        - Build with debug symbols (both architectures)"
 	@echo "  examples     - Build example programs"
 	@echo "  test         - Run simple test"
 	@echo "  test-crypto  - Run comprehensive crypto test suite"
@@ -135,8 +199,11 @@ help:
 	@echo "  dist         - Create distribution package"
 	@echo "  help         - Show this help"
 	@echo ""
-	@echo "Library outputs (static only):"
+	@echo "Library outputs (static only, self-contained with secp256k1):"
 	@echo "  $(STATIC_LIB)      - x86_64 static library"
 	@echo "  $(ARM64_STATIC_LIB) - ARM64 static library"
+	@echo ""
+	@echo "Both libraries are self-contained and include secp256k1 objects."
+	@echo "Users only need to link with the library + -lm (no secp256k1 dependency)."
 
-.PHONY: default all arm64 arm64-all debug examples test test-crypto install uninstall clean dist help
+.PHONY: default all x64 x64-only arm64 arm64-all arm64-only debug examples test test-crypto install uninstall clean dist help

README.md

@@ -0,0 +1,433 @@
+# NOSTR Core Library
+
+A comprehensive, self-contained C library for NOSTR protocol implementation with no external cryptographic dependencies.
+
+[![Version](https://img.shields.io/badge/version-0.1.8-blue.svg)](VERSION)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](#license)
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)](#building)
+
+## 🚀 Features
+
+### Core Protocol Support
+- **NIP-01**: Basic protocol flow - event creation, signing, and validation
+- **NIP-04**: Encrypted direct messages (ECDH + AES-CBC + Base64)
+- **NIP-06**: Key derivation from mnemonic (BIP39/BIP32 compliant)  
+- **NIP-13**: Proof of Work for events
+- **NIP-44**: Versioned encrypted direct messages (ECDH + ChaCha20 + HMAC)
+
+### Cryptographic Features
+- **Self-Contained**: No external crypto dependencies (OpenSSL, libwally, etc.)
+- **Secp256k1**: Complete elliptic curve implementation bundled
+- **BIP39**: Mnemonic phrase generation and validation
+- **BIP32**: Hierarchical deterministic key derivation
+- **ChaCha20**: Stream cipher for NIP-44 encryption
+- **AES-CBC**: Block cipher for NIP-04 encryption
+- **Schnorr Signatures**: BIP-340 compliant signing and verification
+
+### Networking & Relay Support
+- **Multi-Relay Queries**: Synchronous querying with progress callbacks
+- **Relay Pools**: Asynchronous connection management with statistics
+- **WebSocket Communication**: Full relay protocol support
+- **Event Deduplication**: Automatic handling of duplicate events across relays
+- **Connection Management**: Automatic reconnection and error handling
+
+### Developer Experience
+- **Zero Dependencies**: Only requires standard C library and math library (`-lm`)
+- **Thread-Safe**: Core cryptographic functions are stateless
+- **Cross-Platform**: Builds on Linux, macOS, Windows
+- **Comprehensive Examples**: Ready-to-run demonstration programs
+- **Automatic Versioning**: Git-tag based version management
+
+## 📦 Quick Start
+
+### Installation
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/yourusername/nostr_core_lib.git
+   cd nostr_core_lib
+   ```
+
+2. **Build the library:**
+   ```bash
+   ./build.sh lib
+   ```
+
+3. **Run examples:**
+   ```bash
+   ./build.sh examples
+   ./examples/simple_keygen
+   ```
+
+### Usage Example
+
+```c
+#include "nostr_core/nostr_core.h"
+#include <stdio.h>
+
+int main() {
+    // Initialize library
+    if (nostr_init() != NOSTR_SUCCESS) {
+        fprintf(stderr, "Failed to initialize NOSTR library\n");
+        return 1;
+    }
+    
+    // Generate keypair
+    unsigned char private_key[32], public_key[32];
+    nostr_generate_keypair(private_key, public_key);
+    
+    // Convert to bech32 format
+    char nsec[100], npub[100];
+    nostr_key_to_bech32(private_key, "nsec", nsec);
+    nostr_key_to_bech32(public_key, "npub", npub);
+    
+    printf("Private key: %s\n", nsec);
+    printf("Public key:  %s\n", npub);
+    
+    // Create and sign event
+    cJSON* event = nostr_create_and_sign_event(1, "Hello NOSTR!", NULL, private_key, 0);
+    if (event) {
+        char* json = cJSON_Print(event);
+        printf("Event: %s\n", json);
+        free(json);
+        cJSON_Delete(event);
+    }
+    
+    nostr_cleanup();
+    return 0;
+}
+```
+
+**Compile and run:**
+```bash
+gcc example.c -o example ./libnostr_core.a -lm
+./example
+```
+
+## 🏗️ Building
+
+### Build Targets
+
+```bash
+./build.sh lib        # Build static library (default)
+./build.sh examples   # Build examples
+./build.sh test       # Run test suite
+./build.sh clean      # Clean build artifacts
+./build.sh install    # Install to system
+```
+
+### Manual Building
+
+```bash
+# Build static library
+make
+
+# Build examples  
+make examples
+
+# Run tests
+make test-crypto
+
+# Clean
+make clean
+```
+
+### Dependencies
+
+**Required:**
+- GCC or compatible C compiler
+- Standard C library
+- Math library (`-lm`)
+
+**Included:**
+- cJSON (JSON parsing)
+- secp256k1 (elliptic curve cryptography)
+- mbedTLS components (selected crypto functions)
+
+## 📚 API Documentation
+
+### Initialization
+```c
+int nostr_init(void);                    // Initialize library (call first)
+void nostr_cleanup(void);                // Cleanup resources (call last)
+const char* nostr_strerror(int error);   // Get error message
+```
+
+### Key Management
+```c
+// Generate random keypair
+int nostr_generate_keypair(unsigned char* private_key, unsigned char* public_key);
+
+// Generate from mnemonic
+int nostr_generate_mnemonic_and_keys(char* mnemonic, size_t mnemonic_size, 
+                                     int account, unsigned char* private_key, 
+                                     unsigned char* public_key);
+
+// Derive from existing mnemonic
+int nostr_derive_keys_from_mnemonic(const char* mnemonic, int account,
+                                    unsigned char* private_key, unsigned char* public_key);
+
+// Format conversion
+int nostr_key_to_bech32(const unsigned char* key, const char* hrp, char* output);
+nostr_input_type_t nostr_detect_input_type(const char* input);
+```
+
+### Event Creation
+```c
+// Create and sign event
+cJSON* nostr_create_and_sign_event(int kind, const char* content, cJSON* tags, 
+                                   const unsigned char* private_key, time_t timestamp);
+
+// Add proof of work
+int nostr_add_proof_of_work(cJSON* event, const unsigned char* private_key, 
+                           int target_difficulty, void (*progress_callback)(...), void* user_data);
+```
+
+### Encryption (NIP-04 & NIP-44)
+```c
+// NIP-04 (AES-CBC)
+int nostr_nip04_encrypt(const unsigned char* sender_private_key,
+                       const unsigned char* recipient_public_key, 
+                       const char* plaintext, char* output, size_t output_size);
+
+int nostr_nip04_decrypt(const unsigned char* recipient_private_key,
+                       const unsigned char* sender_public_key,
+                       const char* encrypted_data, char* output, size_t output_size);
+
+// NIP-44 (ChaCha20)  
+int nostr_nip44_encrypt(const unsigned char* sender_private_key,
+                       const unsigned char* recipient_public_key,
+                       const char* plaintext, char* output, size_t output_size);
+
+int nostr_nip44_decrypt(const unsigned char* recipient_private_key,
+                       const unsigned char* sender_public_key,
+                       const char* encrypted_data, char* output, size_t output_size);
+```
+
+### Relay Communication
+```c
+// Simple relay query
+cJSON* nostr_query_relay_for_event(const char* relay_url, const char* pubkey_hex, int kind);
+
+// Multi-relay synchronous queries
+cJSON** synchronous_query_relays_with_progress(const char** relay_urls, int relay_count,
+                                               cJSON* filter, relay_query_mode_t mode,
+                                               int* result_count, int relay_timeout_seconds,
+                                               relay_progress_callback_t callback, void* user_data);
+
+// Multi-relay publishing
+publish_result_t* synchronous_publish_event_with_progress(const char** relay_urls, int relay_count,
+                                                         cJSON* event, int* success_count,
+                                                         int relay_timeout_seconds,
+                                                         publish_progress_callback_t callback, void* user_data);
+```
+
+### Relay Pools (Asynchronous)
+```c
+// Create and manage relay pool
+nostr_relay_pool_t* nostr_relay_pool_create(void);
+int nostr_relay_pool_add_relay(nostr_relay_pool_t* pool, const char* relay_url);
+void nostr_relay_pool_destroy(nostr_relay_pool_t* pool);
+
+// Subscribe to events
+nostr_pool_subscription_t* nostr_relay_pool_subscribe(
+    nostr_relay_pool_t* pool, const char** relay_urls, int relay_count, cJSON* filter,
+    void (*on_event)(cJSON* event, const char* relay_url, void* user_data),
+    void (*on_eose)(void* user_data), void* user_data);
+
+// Run event loop
+int nostr_relay_pool_run(nostr_relay_pool_t* pool, int timeout_ms);
+int nostr_relay_pool_poll(nostr_relay_pool_t* pool, int timeout_ms);
+```
+
+## 📁 Examples
+
+The library includes comprehensive examples:
+
+- **`simple_keygen`** - Basic key generation and formatting
+- **`keypair_generation`** - Advanced key management
+- **`mnemonic_generation`** - BIP39 mnemonic handling
+- **`mnemonic_derivation`** - NIP-06 key derivation
+- **`utility_functions`** - General utility demonstrations
+- **`input_detection`** - Input type detection and processing
+- **`version_test`** - Library version information
+
+Run all examples:
+```bash
+./build.sh examples
+ls -la examples/
+```
+
+## 🧪 Testing
+
+The library includes extensive tests:
+
+```bash
+# Run all tests
+./build.sh test
+
+# Individual test categories
+cd tests && make test
+```
+
+**Test Categories:**
+- **Core Functionality**: `simple_init_test`, `header_test`
+- **Cryptography**: `chacha20_test`, `nostr_crypto_test`
+- **NIP-04 Encryption**: `nip04_test`
+- **NIP-44 Encryption**: `nip44_test`, `nip44_debug_test`
+- **Key Derivation**: `nostr_test_bip32`
+- **Relay Communication**: `relay_pool_test`, `sync_test`
+- **Proof of Work**: `test_pow_loop`
+
+## 🏗️ Integration
+
+### Static Library Integration
+
+1. **Copy required files to your project:**
+   ```bash
+   cp libnostr_core.a /path/to/your/project/
+   cp nostr_core/nostr_core.h /path/to/your/project/
+   ```
+
+2. **Link in your project:**
+   ```bash
+   gcc your_code.c -L. -lnostr_core -lm -o your_program
+   ```
+
+### Source Integration
+
+1. **Copy source files:**
+   ```bash
+   cp -r nostr_core/ /path/to/your/project/
+   cp -r cjson/ /path/to/your/project/
+   ```
+
+2. **Include in your build:**
+   ```bash
+   gcc your_code.c nostr_core/*.c cjson/cJSON.c -lm -o your_program
+   ```
+
+### Self-Contained Library
+
+The `libnostr_core.a` file is completely self-contained with **no external dependencies**:
+
+- ✅ **No OpenSSL required**
+- ✅ **No libwally required** 
+- ✅ **No system secp256k1 required**
+- ✅ **Only needs math library (`-lm`)**
+
+```bash
+# This is all you need:
+gcc your_app.c ./libnostr_core.a -lm -o your_app
+```
+
+## 🔧 Configuration
+
+### Compile-Time Options
+
+```c
+// Enable debug output
+#define NOSTR_DEBUG_ENABLED
+
+// Crypto-only build (no networking)
+#define NOSTR_CRYPTO_ONLY
+
+// Enable specific NIPs
+#define NOSTR_NIP04_ENABLED
+#define NOSTR_NIP44_ENABLED
+#define NOSTR_NIP13_ENABLED
+```
+
+### Build Flags
+
+```bash
+# Enable all logging
+make LOGGING_FLAGS="-DENABLE_FILE_LOGGING -DENABLE_WEBSOCKET_LOGGING -DENABLE_DEBUG_LOGGING"
+
+# Debug build
+make debug
+
+# ARM64 cross-compile
+make arm64
+```
+
+## 🌐 Supported Platforms
+
+- **Linux** (x86_64, ARM64)
+- **macOS** (Intel, Apple Silicon)
+- **Windows** (MinGW, MSYS2)
+- **Embedded Systems** (resource-constrained environments)
+
+## 📄 Documentation
+
+- **[LIBRARY_USAGE.md](LIBRARY_USAGE.md)** - Detailed integration guide
+- **[EXPORT_GUIDE.md](EXPORT_GUIDE.md)** - Library export instructions
+- **[AUTOMATIC_VERSIONING.md](AUTOMATIC_VERSIONING.md)** - Version management
+- **API Reference** - Complete documentation in `nostr_core/nostr_core.h`
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Make your changes and add tests
+4. Run the test suite: `./build.sh test`
+5. Commit your changes: `git commit -m 'Add amazing feature'`
+6. Push to the branch: `git push origin feature/amazing-feature`
+7. Open a Pull Request
+
+## 📈 Version History
+
+Current version: **0.1.8**
+
+The library uses automatic semantic versioning based on Git tags. Each build increments the patch version automatically.
+
+- `v0.1.x` - Initial development releases
+- Focus on core protocol implementation and self-contained crypto
+- Full NIP-01, NIP-04, NIP-06, NIP-13, NIP-44 support
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Build fails with secp256k1 errors:**
+```bash
+cd secp256k1
+./autogen.sh
+./configure --enable-module-schnorrsig --enable-module-ecdh
+make
+cd ..
+./build.sh lib
+```
+
+**Library too large:**
+The library is intentionally large (~2.4MB) because it includes all secp256k1 cryptographic functions for complete self-containment.
+
+**Linking errors:**
+Make sure to include the math library:
+```bash
+gcc your_code.c ./libnostr_core.a -lm  # Note the -lm flag
+```
+
+### Getting Help
+
+- Check the `examples/` directory for working code
+- Run `./build.sh test` to verify your environment
+- Review the comprehensive API documentation in `nostr_core/nostr_core.h`
+
+## 📜 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **NOSTR Protocol** - The decentralized social media protocol
+- **secp256k1** - Bitcoin's elliptic curve library
+- **cJSON** - Lightweight JSON parser
+- **mbedTLS** - Cryptographic building blocks
+- **NOSTR Community** - For protocol specification and feedback
+
+---
+
+**Built with ❤️ for the decentralized web**
+
+*Self-contained • Zero dependencies • Production ready*

VERSION

@@ -1 +1 @@
-1.0.157
+0.1.18

VERSIONING.md

@@ -1,122 +0,0 @@
-# Version Management System
-
-This project implements an automated version management system for C applications with auto-incrementing build numbers.
-
-## Overview
-
-The version management system consists of:
-- **Semantic versioning** (Major.Minor.Patch) in `VERSION` file
-- **Auto-incrementing build numbers** in `.build_number` file
-- **Generated version header** (`version.h`) with all version info
-- **Build-time integration** via `scripts/generate_version.sh`
-
-## Files
-
-### Core Files
-- `VERSION` - Contains semantic version (e.g., "1.0.0")
-- `.build_number` - Contains current build number (auto-incremented)
-- `scripts/generate_version.sh` - Version generation script
-- `version.h` - Generated header (auto-created, do not edit)
-
-### Integration Files
-- `build.sh` - Modified to call version generation
-- `.gitignore` - Excludes generated `version.h`
-
-## Usage
-
-### Building
-Every time you run `./build.sh`, the build number automatically increments:
-
-```bash
-./build.sh  # Build #1
-./build.sh  # Build #2
-./build.sh  # Build #3
-```
-
-### Version Display
-The application shows version information in multiple ways:
-
-**Command Line:**
-```bash
-./build/c_nostr --version
-./build/c_nostr -v
-```
-
-**Interactive Mode:**
-- ASCII art title with version
-- Header shows: `NOSTR TERMINAL v1.0.0 (Build #3, 2025-07-21)`
-
-### Updating Semantic Version
-To update the major/minor/patch version:
-
-```bash
-echo "1.1.0" > VERSION
-```
-
-The next build will be `v1.1.0 (Build #4)`.
-
-## Generated Macros
-
-The `version.h` file contains these macros:
-
-```c
-#define VERSION_MAJOR 1
-#define VERSION_MINOR 0
-#define VERSION_PATCH 0
-#define VERSION_BUILD 3
-#define VERSION_STRING "1.0.0"
-#define VERSION_FULL "1.0.0.3"
-#define BUILD_NUMBER 3
-#define BUILD_DATE "2025-07-21"
-#define BUILD_TIME "14:53:32"
-#define BUILD_TIMESTAMP "2025-07-21 14:53:32"
-#define GIT_HASH ""
-#define GIT_BRANCH ""
-#define VERSION_DISPLAY "v1.0.0 (Build #3)"
-#define VERSION_FULL_DISPLAY "v1.0.0 (Build #3, 2025-07-21)"
-```
-
-## Integration in Code
-
-Include the version header:
-```c
-#include "version.h"
-```
-
-Use version macros:
-```c
-printf("NOSTR TERMINAL %s\n", VERSION_FULL_DISPLAY);
-printf("Built: %s\n", BUILD_TIMESTAMP);
-```
-
-## Best Practices
-
-1. **Never edit `version.h`** - it's auto-generated
-2. **Commit `.build_number`** - tracks build history
-3. **Update `VERSION` manually** - for semantic version changes
-4. **Build increments automatically** - no manual intervention needed
-
-## Version History
-
-Build numbers are persistent and increment across sessions:
-- Build #1: Initial implementation
-- Build #2: First rebuild test
-- Build #3: Added --version flag
-- Build #4: Next build...
-
-## ASCII Art Integration
-
-The version system integrates with the ASCII art title display:
-
-```
-███    ██          ██████  ███████         ████████ ███████ ██████  
-████   ██         ██    ██ ██                 ██    ██      ██   ██ 
-██ ██  ██         ██    ██ ███████            ██    █████   ██████  
-██  ██ ██         ██    ██      ██            ██    ██      ██   ██ 
-██   ████ ███████  ██████  ███████ ███████    ██    ███████ ██   ██ 
-
-NOSTR TERMINAL v1.0.0 (Build #3, 2025-07-21) - user_abc123
-================================================================
-```
-
-This provides a professional, branded experience with clear version identification.

build.sh

@@ -2,6 +2,7 @@
 
 # NOSTR Core Library Build Script
 # Provides convenient build targets for the standalone library
+# Automatically increments patch version with each build
 
 set -e  # Exit on any error
 
@@ -29,28 +30,143 @@ print_error() {
     echo -e "${RED}[ERROR]${NC} $1"
 }
 
+# Function to automatically increment version
+increment_version() {
+    print_status "Incrementing version..."
+    
+    # Check if we're in a git repository
+    if ! git rev-parse --git-dir > /dev/null 2>&1; then
+        print_warning "Not in a git repository - skipping version increment"
+        return 0
+    fi
+    
+    # Get the highest version tag (not necessarily the most recent chronologically)
+    LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "v0.1.0")
+    if [[ -z "$LATEST_TAG" ]]; then
+        LATEST_TAG="v0.1.0"
+    fi
+    
+    # Extract version components (remove 'v' prefix if present)
+    VERSION=${LATEST_TAG#v}
+    
+    # Parse major.minor.patch
+    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"
+        return 1
+    fi
+    
+    # Increment patch version
+    NEW_PATCH=$((PATCH + 1))
+    NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
+    
+    print_status "Current version: $LATEST_TAG"
+    print_status "New version: $NEW_VERSION"
+    
+    # Create new git tag
+    if git tag "$NEW_VERSION" 2>/dev/null; then
+        print_success "Created new version tag: $NEW_VERSION"
+        
+        # Generate version.h header file
+        cat > nostr_core/version.h << EOF
+/*
+ * NOSTR Core Library - Auto-Generated Version Header
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build.sh
+ */
+
+#ifndef NOSTR_VERSION_H
+#define NOSTR_VERSION_H
+
+#define VERSION_MAJOR ${MAJOR}
+#define VERSION_MINOR ${MINOR}
+#define VERSION_PATCH ${NEW_PATCH}
+#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
+#define VERSION_TAG "${NEW_VERSION}"
+
+/* Build information */
+#define BUILD_DATE "$(date +%Y-%m-%d)"
+#define BUILD_TIME "$(date +%H:%M:%S)"
+#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
+
+/* Git information */
+#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
+
+/* Display versions */
+#define VERSION_DISPLAY "${NEW_VERSION}"
+#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
+
+/* Version API functions */
+const char* nostr_core_get_version(void);
+const char* nostr_core_get_version_full(void);
+const char* nostr_core_get_build_info(void);
+
+#endif /* NOSTR_VERSION_H */
+EOF
+
+        # Generate version.c implementation file
+        cat > nostr_core/version.c << EOF
+/*
+ * NOSTR Core Library - Auto-Generated Version Implementation
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build.sh
+ */
+
+#include "version.h"
+
+const char* nostr_core_get_version(void) {
+    return VERSION_TAG;
+}
+
+const char* nostr_core_get_version_full(void) {
+    return VERSION_FULL_DISPLAY;
+}
+
+const char* nostr_core_get_build_info(void) {
+    return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
+}
+EOF
+        
+        print_success "Generated version.h and version.c"
+    else
+        print_warning "Tag $NEW_VERSION already exists - using existing version"
+        NEW_VERSION=$LATEST_TAG
+    fi
+    
+    # Update VERSION file for compatibility
+    echo "${NEW_VERSION#v}" > VERSION
+    print_success "Updated VERSION file to ${NEW_VERSION#v}"
+}
+
 # Function to show usage
 show_usage() {
     echo "NOSTR Core Library Build Script"
     echo "==============================="
     echo ""
-    echo "Usage: $0 [target]"
+    echo "Usage: $0 [target] [architecture]"
     echo ""
     echo "Available targets:"
     echo "  clean       - Clean all build artifacts"
-    echo "  lib         - Build static library (default)"
-    echo "  shared      - Build shared library"
-    echo "  all         - Build both static and shared libraries"
+    echo "  lib         - Build static libraries for both x64 and ARM64 (default)"
+    echo "  x64         - Build x64 static library only"
+    echo "  arm64       - Build ARM64 static library only"
+    echo "  all         - Build both architectures and examples"
     echo "  examples    - Build example programs"
     echo "  test        - Run tests"
     echo "  install     - Install library to system"
     echo "  uninstall   - Remove library from system"
     echo "  help        - Show this help message"
     echo ""
-    echo "Library outputs:"
-    echo "  libnostr_core.a       - Static library"
-    echo "  libnostr_core.so      - Shared library"
+    echo "Library outputs (both self-contained with secp256k1):"
+    echo "  libnostr_core.a       - x86_64 static library"
+    echo "  libnostr_core_arm64.a - ARM64 static library"
     echo "  examples/*            - Example programs"
+    echo ""
+    echo "Both libraries include secp256k1 objects internally."
+    echo "Users only need to link with the library + -lm."
 }
 
 # Parse command line arguments
@@ -64,20 +180,70 @@ case "$TARGET" in
         ;;
         
     lib|library)
-        print_status "Building static library..."
+        increment_version
+        print_status "Building both x64 and ARM64 static libraries..."
         make clean
         make
+        
+        # Check both libraries were built
+        SUCCESS=0
+        if [ -f "libnostr_core.a" ]; then
+            SIZE_X64=$(stat -c%s "libnostr_core.a")
+            print_success "x64 static library built successfully (${SIZE_X64} bytes)"
+            SUCCESS=$((SUCCESS + 1))
+        else
+            print_error "Failed to build x64 static library"
+        fi
+        
+        if [ -f "libnostr_core_arm64.a" ]; then
+            SIZE_ARM64=$(stat -c%s "libnostr_core_arm64.a")
+            print_success "ARM64 static library built successfully (${SIZE_ARM64} bytes)"
+            SUCCESS=$((SUCCESS + 1))
+        else
+            print_error "Failed to build ARM64 static library"
+        fi
+        
+        if [ $SUCCESS -eq 2 ]; then
+            print_success "Both architectures built successfully!"
+            ls -la libnostr_core*.a
+        else
+            print_error "Failed to build all libraries"
+            exit 1
+        fi
+        ;;
+        
+    x64|x64-only)
+        increment_version
+        print_status "Building x64 static library only..."
+        make clean
+        make x64
         if [ -f "libnostr_core.a" ]; then
             SIZE=$(stat -c%s "libnostr_core.a")
-            print_success "Static library built successfully (${SIZE} bytes)"
+            print_success "x64 static library built successfully (${SIZE} bytes)"
             ls -la libnostr_core.a
         else
-            print_error "Failed to build static library"
+            print_error "Failed to build x64 static library"
+            exit 1
+        fi
+        ;;
+        
+    arm64|arm64-only)
+        increment_version
+        print_status "Building ARM64 static library only..."
+        make clean
+        make arm64
+        if [ -f "libnostr_core_arm64.a" ]; then
+            SIZE=$(stat -c%s "libnostr_core_arm64.a")
+            print_success "ARM64 static library built successfully (${SIZE} bytes)"
+            ls -la libnostr_core_arm64.a
+        else
+            print_error "Failed to build ARM64 static library"
             exit 1
         fi
         ;;
         
     shared)
+        increment_version
         print_status "Building shared library..."
         make clean
         make libnostr_core.so
@@ -92,20 +258,55 @@ case "$TARGET" in
         ;;
         
     all)
-        print_status "Building all libraries..."
+        increment_version
+        print_status "Building all libraries and examples..."
         make clean
         make all
-        print_success "All libraries built successfully"
-        ls -la libnostr_core.*
+        
+        # Check both libraries and examples were built
+        SUCCESS=0
+        if [ -f "libnostr_core.a" ]; then
+            SIZE_X64=$(stat -c%s "libnostr_core.a")
+            print_success "x64 static library built successfully (${SIZE_X64} bytes)"
+            SUCCESS=$((SUCCESS + 1))
+        else
+            print_error "Failed to build x64 static library"
+        fi
+        
+        if [ -f "libnostr_core_arm64.a" ]; then
+            SIZE_ARM64=$(stat -c%s "libnostr_core_arm64.a")
+            print_success "ARM64 static library built successfully (${SIZE_ARM64} bytes)"
+            SUCCESS=$((SUCCESS + 1))
+        else
+            print_error "Failed to build ARM64 static library"
+        fi
+        
+        if [ $SUCCESS -eq 2 ]; then
+            print_success "All libraries and examples built successfully!"
+            ls -la libnostr_core*.a
+            ls -la examples/
+        else
+            print_error "Failed to build all components"
+            exit 1
+        fi
         ;;
         
     examples)
-        print_status "Building examples..."
+        increment_version
+        print_status "Building both libraries and examples..."
         make clean
         make
         make examples
-        print_success "Examples built successfully"
-        ls -la examples/
+        
+        # Verify libraries were built
+        if [ -f "libnostr_core.a" ] && [ -f "libnostr_core_arm64.a" ]; then
+            print_success "Both libraries and examples built successfully"
+            ls -la libnostr_core*.a
+            ls -la examples/
+        else
+            print_error "Failed to build libraries for examples"
+            exit 1
+        fi
         ;;
         
     test)
@@ -135,6 +336,7 @@ case "$TARGET" in
         ;;
 
     install)
+        increment_version
         print_status "Installing library to system..."
         make clean
         make all

examples/version_test.c

@@ -0,0 +1,34 @@
+/*
+ * NOSTR Core Library - Version Test Example
+ * Demonstrates the automatic version increment system
+ */
+
+#include <stdio.h>
+#include "nostr_core.h"
+#include "version.h"
+
+int main() {
+    printf("NOSTR Core Library Version Test\n");
+    printf("===============================\n\n");
+    
+    // Display version information
+    printf("Version: %s\n", nostr_core_get_version());
+    printf("Full Version: %s\n", nostr_core_get_version_full());
+    printf("Build Info: %s\n", nostr_core_get_build_info());
+    
+    printf("\nVersion Macros:\n");
+    printf("VERSION_MAJOR: %d\n", VERSION_MAJOR);
+    printf("VERSION_MINOR: %d\n", VERSION_MINOR);
+    printf("VERSION_PATCH: %d\n", VERSION_PATCH);
+    printf("VERSION_STRING: %s\n", VERSION_STRING);
+    printf("VERSION_TAG: %s\n", VERSION_TAG);
+    
+    printf("\nBuild Information:\n");
+    printf("BUILD_DATE: %s\n", BUILD_DATE);
+    printf("BUILD_TIME: %s\n", BUILD_TIME);
+    printf("BUILD_TIMESTAMP: %s\n", BUILD_TIMESTAMP);
+    printf("GIT_HASH: %s\n", GIT_HASH);
+    printf("GIT_BRANCH: %s\n", GIT_BRANCH);
+    
+    return 0;
+}

nostr_core/cJSON.h

@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 18
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* Limits the length of circular references can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_CIRCULAR_LIMIT
+#define CJSON_CIRCULAR_LIMIT 10000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

nostr_core/core.c

@@ -421,7 +421,33 @@ int nostr_decode_nsec(const char* input, unsigned char* private_key) {
     return NOSTR_SUCCESS;
 }
 
-
+int nostr_decode_npub(const char* input, unsigned char* public_key) {
+    if (!input || !public_key) {
+        return NOSTR_ERROR_INVALID_INPUT;
+    }
+    
+    nostr_input_type_t type = nostr_detect_input_type(input);
+    
+    if (type == NOSTR_INPUT_NSEC_HEX) {  // Actually public key hex
+        if (nostr_hex_to_bytes(input, public_key, 32) != NOSTR_SUCCESS) {
+            return NOSTR_ERROR_INVALID_INPUT;
+        }
+    } else if (strncmp(input, "npub1", 4) == 0) {  // Bech32 npub
+        size_t decoded_len;
+        if (!bech32_decode(input, "npub", public_key, &decoded_len)) {
+            return NOSTR_ERROR_INVALID_INPUT;
+        }
+        if (decoded_len != 32) {
+            return NOSTR_ERROR_INVALID_INPUT;
+        }
+    } else {
+        return NOSTR_ERROR_INVALID_INPUT;
+    }
+    
+    // Validate the public key (could add nostr_ec_public_key_verify if it exists)
+    
+    return NOSTR_SUCCESS;
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

nostr_core/nostr_core.h

@@ -318,7 +318,14 @@ nostr_input_type_t nostr_detect_input_type(const char* input);
  */
 int nostr_decode_nsec(const char* input, unsigned char* private_key);
 
-
+/**
+ * Validate and decode an npub (hex or bech32) to private key
+ * 
+ * @param input Input nsec string
+ * @param private_key Output buffer for private key (32 bytes)
+ * @return NOSTR_SUCCESS on success, error code on failure
+ */
+int nostr_decode_npub(const char* input, unsigned char* private_key);
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -346,9 +353,11 @@ int nostr_add_proof_of_work(cJSON* event, const unsigned char* private_key,
 
 
 
-// =============================================================================
-// RELAY COMMUNICATION
-// =============================================================================
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//          RELAYS - SYNCHRONOUS MULTI-RELAY QUERIES AND PUBLISHING
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Query a relay for a specific event
@@ -361,10 +370,6 @@ int nostr_add_proof_of_work(cJSON* event, const unsigned char* private_key,
 cJSON* nostr_query_relay_for_event(const char* relay_url, const char* pubkey_hex, int kind);
 
 
-// =============================================================================
-// SYNCHRONOUS MULTI-RELAY QUERIES AND PUBLISHING
-// =============================================================================
-
 // Query mode enum
 typedef enum {
     RELAY_QUERY_FIRST_RESULT,    // Return as soon as first event is found
@@ -448,9 +453,15 @@ publish_result_t* synchronous_publish_event_with_progress(
     void* user_data
 );
 
-// =============================================================================
-// RELAY POOL MANAGEMENT
-// =============================================================================
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//          RELAYS - ASYNCHRONOUS RELAY POOLS
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 // Forward declarations for relay pool types
 typedef struct nostr_relay_pool nostr_relay_pool_t;

nostr_core/nostr_crypto.c

@@ -24,10 +24,11 @@
 // UTILITY FUNCTIONS
 // =============================================================================
 
-// Memory clearing utility
-static void memory_clear(void *p, size_t len) {
+// Memory clearing utility - accepts const pointers for security clearing
+static void memory_clear(const void *p, size_t len) {
     if (p && len) {
-        memset(p, 0, len);
+        // Cast away const for memset - this is safe for security clearing
+        memset((void *)p, 0, len);
     }
 }
 

tests/Makefile

@@ -16,6 +16,7 @@ RELAY_POOL_TEST_EXEC = relay_pool_test
 EVENT_GEN_TEST_EXEC = test_event_generation
 POW_LOOP_TEST_EXEC = test_pow_loop
 NIP04_TEST_EXEC = nip04_test
+STATIC_LINKING_TEST_EXEC = static_linking_only_test
 ARM64_CRYPTO_TEST_EXEC = nostr_crypto_test_arm64
 ARM64_CORE_TEST_EXEC = nostr_core_test_arm64
 ARM64_RELAY_POOL_TEST_EXEC = relay_pool_test_arm64
@@ -54,6 +55,11 @@ $(NIP04_TEST_EXEC): nip04_test.c
 	@echo "Building NIP-04 encryption test suite (x86_64)..."
 	$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
 
+# Build static linking test executable (x86_64)
+$(STATIC_LINKING_TEST_EXEC): static_linking_only_test.c
+	@echo "Building static linking verification test (x86_64)..."
+	$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
+
 # Build simple initialization test executable (x86_64)
 simple_init_test: simple_init_test.c
 	@echo "Building simple initialization test program (x86_64)..."
@@ -99,6 +105,7 @@ sync_test: sync_test.c
 	@echo "Building synchronous relay query test program (x86_64)..."
 	$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
 
+
 # Build crypto test ARM64 executable
 $(ARM64_CRYPTO_TEST_EXEC): nostr_crypto_test.c
 	@echo "Building crypto test suite (ARM64)..."
@@ -142,8 +149,13 @@ test-nip04: $(NIP04_TEST_EXEC)
 	@echo "Running NIP-04 encryption tests (x86_64)..."
 	./$(NIP04_TEST_EXEC)
 
+# Run static linking verification test (x86_64)
+test-static-linking: $(STATIC_LINKING_TEST_EXEC)
+	@echo "Running static linking verification test (x86_64)..."
+	./$(STATIC_LINKING_TEST_EXEC)
+
 # Run all test suites (x86_64)
-test: test-crypto test-core test-relay-pool test-nip04
+test: test-crypto test-core test-relay-pool test-nip04 test-static-linking
 
 # Run crypto tests ARM64 (requires qemu-user-static or ARM64 system)
 test-crypto-arm64: $(ARM64_CRYPTO_TEST_EXEC)
@@ -190,7 +202,7 @@ test-all: test test-arm64
 # Clean
 clean:
 	@echo "Cleaning test artifacts..."
-	rm -f $(CRYPTO_TEST_EXEC) $(CORE_TEST_EXEC) $(RELAY_POOL_TEST_EXEC) $(EVENT_GEN_TEST_EXEC) $(POW_LOOP_TEST_EXEC) $(NIP04_TEST_EXEC) $(ARM64_CRYPTO_TEST_EXEC) $(ARM64_CORE_TEST_EXEC) $(ARM64_RELAY_POOL_TEST_EXEC) $(ARM64_NIP04_TEST_EXEC)
+	rm -f $(CRYPTO_TEST_EXEC) $(CORE_TEST_EXEC) $(RELAY_POOL_TEST_EXEC) $(EVENT_GEN_TEST_EXEC) $(POW_LOOP_TEST_EXEC) $(NIP04_TEST_EXEC) $(STATIC_LINKING_TEST_EXEC) $(ARM64_CRYPTO_TEST_EXEC) $(ARM64_CORE_TEST_EXEC) $(ARM64_RELAY_POOL_TEST_EXEC) $(ARM64_NIP04_TEST_EXEC)
 
 # Help
 help:
@@ -198,17 +210,18 @@ help:
 	@echo "================"
 	@echo ""
 	@echo "Available targets:"
-	@echo "  all             - Build all test executables (x86_64)"
-	@echo "  all-arch        - Build test executables for both x86_64 and ARM64"
-	@echo "  test-crypto     - Build and run crypto tests (x86_64)"
-	@echo "  test-core       - Build and run core tests (x86_64)"
-	@echo "  test-relay-pool - Build and run relay pool tests (x86_64)"
-	@echo "  test-nip04      - Build and run NIP-04 encryption tests (x86_64)"
-	@echo "  test            - Build and run all test suites (x86_64)"
-	@echo "  test-arm64      - Build and run all test suites (ARM64)"
-	@echo "  test-all        - Run tests on both architectures"
-	@echo "  clean           - Remove test artifacts"
-	@echo "  help            - Show this help"
+	@echo "  all                  - Build all test executables (x86_64)"
+	@echo "  all-arch             - Build test executables for both x86_64 and ARM64"
+	@echo "  test-crypto          - Build and run crypto tests (x86_64)"
+	@echo "  test-core            - Build and run core tests (x86_64)"
+	@echo "  test-relay-pool      - Build and run relay pool tests (x86_64)"
+	@echo "  test-nip04           - Build and run NIP-04 encryption tests (x86_64)"
+	@echo "  test-static-linking  - Build and run static linking verification test (x86_64)"
+	@echo "  test                 - Build and run all test suites (x86_64)"
+	@echo "  test-arm64           - Build and run all test suites (ARM64)"
+	@echo "  test-all             - Run tests on both architectures"
+	@echo "  clean                - Remove test artifacts"
+	@echo "  help                 - Show this help"
 	@echo ""
 	@echo "Test Executables:"
 	@echo "  $(CRYPTO_TEST_EXEC)           - x86_64 crypto test binary"
@@ -221,9 +234,10 @@ help:
 	@echo "  $(ARM64_NIP04_TEST_EXEC)      - ARM64 NIP-04 encryption test binary"
 	@echo ""
 	@echo "Test Coverage:"
-	@echo "  Crypto Tests     - Low-level cryptographic primitives (SHA-256, HMAC, secp256k1, BIP39, BIP32)"
-	@echo "  Core Tests       - High-level NOSTR functionality with nak compatibility validation"
-	@echo "  Relay Pool Tests - Relay pool event processing with real NOSTR relays"
-	@echo "  NIP-04 Tests     - NOSTR NIP-04 encryption/decryption with reference test vectors"
+	@echo "  Crypto Tests         - Low-level cryptographic primitives (SHA-256, HMAC, secp256k1, BIP39, BIP32)"
+	@echo "  Core Tests           - High-level NOSTR functionality with nak compatibility validation"
+	@echo "  Relay Pool Tests     - Relay pool event processing with real NOSTR relays"
+	@echo "  NIP-04 Tests         - NOSTR NIP-04 encryption/decryption with reference test vectors"
+	@echo "  Static Linking Tests - Verify library has no external crypto dependencies (self-contained)"
 
-.PHONY: all all-arch test-crypto test-core test-relay-pool test test-crypto-arm64 test-core-arm64 test-relay-pool-arm64 test-arm64 test-all clean help
+.PHONY: all all-arch test-crypto test-core test-relay-pool test-nip04 test-static-linking test test-crypto-arm64 test-core-arm64 test-relay-pool-arm64 test-arm64 test-all clean help

tests/static_linking_only_test.c

@@ -0,0 +1,416 @@
+/*
+ * NOSTR Core Library - Static Linking Only Test
+ * 
+ * This test verifies that the library maintains its self-contained,
+ * static-only design with no external cryptographic dependencies.
+ * 
+ * Test Categories:
+ * 1. Library dependency analysis using ldd/otool
+ * 2. Symbol resolution verification using nm/objdump  
+ * 3. Build process validation
+ * 4. Runtime independence verification
+ * 5. Library size and content verification
+ */
+
+#define _GNU_SOURCE  // For popen/pclose on Linux
+#include "../nostr_core/nostr_core.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include "../cjson/cJSON.h"
+
+// ANSI color codes for output
+#define GREEN   "\033[32m"
+#define RED     "\033[31m" 
+#define YELLOW  "\033[33m"
+#define BLUE    "\033[34m"
+#define RESET   "\033[0m"
+
+// Test result tracking
+static int tests_run = 0;
+static int tests_passed = 0;
+
+// Helper function to run shell commands and capture output
+static int run_command(const char* command, char* output, size_t output_size) {
+    FILE* fp = popen(command, "r");
+    if (!fp) {
+        return -1;
+    }
+    
+    size_t total = 0;
+    while (total < output_size - 1 && fgets(output + total, output_size - total, fp)) {
+        total = strlen(output);
+    }
+    
+    int status = pclose(fp);
+    return WEXITSTATUS(status);
+}
+
+// Helper function to check if file exists
+static int file_exists(const char* path) {
+    struct stat st;
+    return stat(path, &st) == 0;
+}
+
+// Test macro
+#define RUN_TEST(test_name, test_func) do { \
+    printf(BLUE "[TEST] " RESET "%s...\n", test_name); \
+    tests_run++; \
+    if (test_func()) { \
+        printf(GREEN "[PASS] " RESET "%s\n\n", test_name); \
+        tests_passed++; \
+    } else { \
+        printf(RED "[FAIL] " RESET "%s\n\n", test_name); \
+    } \
+} while(0)
+
+// Test 1: Library Dependency Analysis
+static int test_library_dependency_analysis(void) {
+    char command[512];
+    char output[4096];
+    int result;
+    
+    // Check if we have the main library
+    if (!file_exists("../libnostr_core.a")) {
+        printf(RED "ERROR: " RESET "libnostr_core.a not found. Run 'make' first.\n");
+        return 0;
+    }
+    
+    // Create a simple test binary to analyze
+    printf("Creating test binary for dependency analysis...\n");
+    
+    const char* test_code = 
+        "#include \"../nostr_core/nostr_core.h\"\n"
+        "#include <stdio.h>\n"
+        "int main() {\n"
+        "    if (nostr_init() == NOSTR_SUCCESS) {\n"
+        "        unsigned char privkey[32], pubkey[32];\n"
+        "        if (nostr_generate_keypair(privkey, pubkey) == NOSTR_SUCCESS) {\n"
+        "            printf(\"Crypto test passed\\n\");\n"
+        "        }\n"
+        "        nostr_cleanup();\n"
+        "    }\n"
+        "    return 0;\n"
+        "}\n";
+    
+    FILE* fp = fopen("/tmp/static_test.c", "w");
+    if (!fp) {
+        printf(RED "ERROR: " RESET "Cannot create temporary test file\n");
+        return 0;
+    }
+    fputs(test_code, fp);
+    fclose(fp);
+    
+    // Compile the test binary
+    snprintf(command, sizeof(command), 
+        "gcc -I.. -Wall -Wextra -std=c99 /tmp/static_test.c -o /tmp/static_test ../libnostr_core.a -lm -static 2>/dev/null");
+    
+    result = system(command);
+    if (result != 0) {
+        printf(RED "ERROR: " RESET "Failed to compile test binary\n");
+        return 0;
+    }
+    
+    // Analyze dependencies with ldd (Linux) or otool (macOS)
+    printf("Analyzing binary dependencies...\n");
+    
+#ifdef __linux__
+    snprintf(command, sizeof(command), "ldd /tmp/static_test 2>&1");
+#elif __APPLE__
+    snprintf(command, sizeof(command), "otool -L /tmp/static_test 2>&1");
+#else
+    printf(YELLOW "WARNING: " RESET "Unknown platform, skipping dependency analysis\n");
+    cleanup_and_return:
+    unlink("/tmp/static_test.c");
+    unlink("/tmp/static_test");
+    return 1;
+#endif
+    
+    result = run_command(command, output, sizeof(output));
+    
+    // Check for problematic dynamic dependencies
+    const char* forbidden_libs[] = {
+        "libsecp256k1",
+        "libssl", 
+        "libcrypto",
+        "libwally",
+        "libsodium"
+    };
+    
+    int found_forbidden = 0;
+    for (int i = 0; i < 5; i++) {
+        if (strstr(output, forbidden_libs[i])) {
+            printf(RED "ERROR: " RESET "Found forbidden dynamic dependency: %s\n", forbidden_libs[i]);
+            found_forbidden = 1;
+        }
+    }
+    
+    if (!found_forbidden) {
+        printf(GREEN "GOOD: " RESET "No forbidden cryptographic dependencies found\n");
+    }
+    
+    // For static binaries, ldd should say "not a dynamic executable" or show minimal deps
+#ifdef __linux__ 
+    if (strstr(output, "not a dynamic executable") || strstr(output, "statically linked")) {
+        printf(GREEN "EXCELLENT: " RESET "Binary is statically linked\n");
+    } else {
+        printf(YELLOW "INFO: " RESET "Binary appears to have some dynamic dependencies:\n");
+        printf("%s\n", output);
+    }
+#endif
+    
+    // Cleanup
+    unlink("/tmp/static_test.c");
+    unlink("/tmp/static_test");
+    
+    return !found_forbidden;
+}
+
+// Test 2: Symbol Resolution Verification
+static int test_symbol_resolution_verification(void) {
+    char command[512];
+    char output[8192];
+    
+    printf("Verifying secp256k1 symbols are present in static library...\n");
+    
+    // Check that critical secp256k1 symbols are present
+    snprintf(command, sizeof(command), "nm ../libnostr_core.a 2>/dev/null | grep secp256k1");
+    
+    if (run_command(command, output, sizeof(output)) != 0 || strlen(output) == 0) {
+        printf(RED "ERROR: " RESET "No secp256k1 symbols found in library\n");
+        return 0;
+    }
+    
+    // Check for key secp256k1 functions
+    const char* required_symbols[] = {
+        "secp256k1_context_create",
+        "secp256k1_ec_pubkey_create", 
+        "secp256k1_schnorrsig_sign",
+        "secp256k1_schnorrsig_verify",
+        "secp256k1_ecdh"
+    };
+    
+    int symbols_found = 0;
+    for (int i = 0; i < 5; i++) {
+        if (strstr(output, required_symbols[i])) {
+            symbols_found++;
+            printf(GREEN "FOUND: " RESET "%s\n", required_symbols[i]);
+        } else {
+            printf(YELLOW "MISSING: " RESET "%s\n", required_symbols[i]);
+        }
+    }
+    
+    if (symbols_found >= 3) {
+        printf(GREEN "GOOD: " RESET "Found %d/5 critical secp256k1 symbols\n", symbols_found);
+        return 1;
+    } else {
+        printf(RED "ERROR: " RESET "Only found %d/5 critical secp256k1 symbols\n", symbols_found);
+        return 0;
+    }
+}
+
+// Test 3: Build Process Validation
+static int test_build_process_validation(void) {
+    char command[512];
+    int result;
+    
+    printf("Testing minimal build requirements...\n");
+    
+    // Test that we can build with only libnostr_core.a and -lm
+    const char* minimal_test = 
+        "#include \"../nostr_core/nostr_core.h\"\n"
+        "int main() { return nostr_init() == NOSTR_SUCCESS ? 0 : 1; }\n";
+    
+    FILE* fp = fopen("/tmp/minimal_test.c", "w");
+    if (!fp) return 0;
+    fputs(minimal_test, fp);
+    fclose(fp);
+    
+    // Try to build with minimal dependencies
+    snprintf(command, sizeof(command), 
+        "gcc -I.. -Wall -Wextra -std=c99 /tmp/minimal_test.c -o /tmp/minimal_test ../libnostr_core.a -lm 2>/dev/null");
+    
+    result = system(command);
+    
+    unlink("/tmp/minimal_test.c");
+    
+    if (result == 0) {
+        printf(GREEN "EXCELLENT: " RESET "Can build with only libnostr_core.a and -lm\n");
+        
+        // Test that it actually runs
+        result = system("/tmp/minimal_test");
+        unlink("/tmp/minimal_test");
+        
+        if (result == 0) {
+            printf(GREEN "EXCELLENT: " RESET "Minimal binary runs successfully\n");
+            return 1;
+        } else {
+            printf(RED "ERROR: " RESET "Minimal binary failed to run\n");
+            return 0;
+        }
+    } else {
+        printf(RED "ERROR: " RESET "Cannot build with minimal dependencies\n");
+        unlink("/tmp/minimal_test");
+        return 0;
+    }
+}
+
+// Test 4: Runtime Independence Test
+static int test_runtime_independence(void) {
+    printf("Testing runtime independence (crypto functionality)...\n");
+    
+    // Initialize the library
+    if (nostr_init() != NOSTR_SUCCESS) {
+        printf(RED "ERROR: " RESET "Library initialization failed\n");
+        return 0;
+    }
+    
+    // Test key generation
+    unsigned char private_key[32];
+    unsigned char public_key[32];
+    
+    if (nostr_generate_keypair(private_key, public_key) != NOSTR_SUCCESS) {
+        printf(RED "ERROR: " RESET "Key generation failed\n");
+        nostr_cleanup();
+        return 0;
+    }
+    printf(GREEN "GOOD: " RESET "Key generation works\n");
+    
+    // Test bech32 encoding
+    char nsec[100], npub[100];
+    if (nostr_key_to_bech32(private_key, "nsec", nsec) != NOSTR_SUCCESS ||
+        nostr_key_to_bech32(public_key, "npub", npub) != NOSTR_SUCCESS) {
+        printf(RED "ERROR: " RESET "Bech32 encoding failed\n");
+        nostr_cleanup();
+        return 0;
+    }
+    printf(GREEN "GOOD: " RESET "Bech32 encoding works\n");
+    
+    // Test signing
+    cJSON* event = nostr_create_and_sign_event(1, "Test message", NULL, private_key, 0);
+    if (!event) {
+        printf(RED "ERROR: " RESET "Event creation/signing failed\n");
+        nostr_cleanup();
+        return 0;
+    }
+    printf(GREEN "GOOD: " RESET "Event signing works\n");
+    cJSON_Delete(event);
+    
+    // Test NIP-44 encryption if available
+    char plaintext[] = "Hello, NOSTR!";
+    char encrypted[1024];
+    char decrypted[1024];
+    
+    // Generate recipient keys
+    unsigned char recipient_private[32], recipient_public[32];
+    nostr_generate_keypair(recipient_private, recipient_public);
+    
+    if (nostr_nip44_encrypt(private_key, recipient_public, plaintext, encrypted, sizeof(encrypted)) == NOSTR_SUCCESS) {
+        if (nostr_nip44_decrypt(recipient_private, public_key, encrypted, decrypted, sizeof(decrypted)) == NOSTR_SUCCESS) {
+            if (strcmp(plaintext, decrypted) == 0) {
+                printf(GREEN "EXCELLENT: " RESET "NIP-44 encryption/decryption works\n");
+            } else {
+                printf(YELLOW "WARNING: " RESET "NIP-44 decryption mismatch\n");
+            }
+        } else {
+            printf(YELLOW "WARNING: " RESET "NIP-44 decryption failed\n");
+        }
+    } else {
+        printf(YELLOW "WARNING: " RESET "NIP-44 encryption failed (may not be enabled)\n");
+    }
+    
+    nostr_cleanup();
+    return 1;
+}
+
+// Test 5: Library Size and Content Verification
+static int test_library_size_and_content(void) {
+    struct stat st;
+    char command[512];
+    char output[4096];
+    
+    printf("Verifying library size and content...\n");
+    
+    // Check library size
+    if (stat("../libnostr_core.a", &st) != 0) {
+        printf(RED "ERROR: " RESET "Cannot stat libnostr_core.a\n");
+        return 0;
+    }
+    
+    size_t lib_size = st.st_size;
+    printf("Library size: %zu bytes (%.2f MB)\n", lib_size, lib_size / 1024.0 / 1024.0);
+    
+    // Expect "fat" library to be at least 1MB (with secp256k1 bundled)
+    if (lib_size < 1024 * 1024) {
+        printf(YELLOW "WARNING: " RESET "Library seems small (%.2f MB). May not include secp256k1.\n", 
+               lib_size / 1024.0 / 1024.0);
+    } else {
+        printf(GREEN "GOOD: " RESET "Library size suggests secp256k1 is bundled\n");
+    }
+    
+    // List archive contents
+    snprintf(command, sizeof(command), "ar -t ../libnostr_core.a | wc -l");
+    if (run_command(command, output, sizeof(output)) == 0) {
+        int object_count = atoi(output);
+        printf("Archive contains %d object files\n", object_count);
+        
+        if (object_count > 20) {
+            printf(GREEN "EXCELLENT: " RESET "High object count suggests secp256k1 objects included\n");
+        } else {
+            printf(YELLOW "WARNING: " RESET "Low object count (%d). secp256k1 may not be fully bundled\n", object_count);
+        }
+    }
+    
+    // Check for secp256k1-specific object files
+    snprintf(command, sizeof(command), "ar -t ../libnostr_core.a | grep -E '(secp256k1|ecmult)' | head -5");
+    if (run_command(command, output, sizeof(output)) == 0 && strlen(output) > 0) {
+        printf(GREEN "EXCELLENT: " RESET "Found secp256k1 object files in archive:\n");
+        printf("%s", output);
+    } else {
+        printf(YELLOW "WARNING: " RESET "No obvious secp256k1 object files found\n");
+    }
+    
+    return 1;
+}
+
+// Main test runner
+int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+    
+    printf(BLUE "NOSTR Core Library - Static Linking Only Test\n");
+    printf("==============================================" RESET "\n\n");
+    
+    printf("This test verifies that the library maintains its self-contained,\n");
+    printf("static-only design with no external cryptographic dependencies.\n\n");
+    
+    // Run all tests
+    RUN_TEST("Library Dependency Analysis", test_library_dependency_analysis);
+    RUN_TEST("Symbol Resolution Verification", test_symbol_resolution_verification); 
+    RUN_TEST("Build Process Validation", test_build_process_validation);
+    RUN_TEST("Runtime Independence Test", test_runtime_independence);
+    RUN_TEST("Library Size and Content Verification", test_library_size_and_content);
+    
+    // Print summary
+    printf(BLUE "============================================\n");
+    printf("TEST SUMMARY\n");
+    printf("============================================" RESET "\n");
+    printf("Tests run: %d\n", tests_run);
+    printf("Tests passed: %d\n", tests_passed);
+    
+    if (tests_passed == tests_run) {
+        printf(GREEN "ALL TESTS PASSED!" RESET "\n");
+        printf("✅ Library maintains static-only design\n");
+        printf("✅ No external crypto dependencies\n");
+        printf("✅ Self-contained and portable\n");
+    } else {
+        printf(RED "SOME TESTS FAILED!" RESET "\n");
+        printf("❌ %d out of %d tests failed\n", tests_run - tests_passed, tests_run);
+        printf("⚠️  Library may have external dependencies or missing components\n");
+    }
+    
+    return (tests_passed == tests_run) ? 0 : 1;
+}