403 lines
13 KiB
Bash
Executable File
403 lines
13 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# NOSTR Core Library - Customer Build Script with Auto-Detection
|
|
# Automatically detects which NIPs are needed based on #include statements
|
|
|
|
set -e # Exit on error
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
NC='\033[0m' # No Color
|
|
|
|
# Function to print colored output
|
|
print_info() {
|
|
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"
|
|
}
|
|
|
|
# Default values
|
|
ARCHITECTURE=""
|
|
FORCE_NIPS=""
|
|
VERBOSE=false
|
|
HELP=false
|
|
BUILD_TESTS=false
|
|
|
|
# Parse command line arguments
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
x64|x86_64|amd64)
|
|
ARCHITECTURE="x64"
|
|
shift
|
|
;;
|
|
arm64|aarch64)
|
|
ARCHITECTURE="arm64"
|
|
shift
|
|
;;
|
|
--nips=*)
|
|
FORCE_NIPS="${1#*=}"
|
|
shift
|
|
;;
|
|
--verbose|-v)
|
|
VERBOSE=true
|
|
shift
|
|
;;
|
|
--tests)
|
|
BUILD_TESTS=true
|
|
shift
|
|
;;
|
|
--help|-h)
|
|
HELP=true
|
|
shift
|
|
;;
|
|
*)
|
|
print_error "Unknown argument: $1"
|
|
HELP=true
|
|
shift
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Show help
|
|
if [ "$HELP" = true ]; then
|
|
echo "NOSTR Core Library - Customer Build Script"
|
|
echo ""
|
|
echo "Usage: $0 [architecture] [options]"
|
|
echo ""
|
|
echo "Architectures:"
|
|
echo " x64, x86_64, amd64 Build for x86-64 architecture"
|
|
echo " arm64, aarch64 Build for ARM64 architecture"
|
|
echo " (default) Build for current architecture"
|
|
echo ""
|
|
echo "Options:"
|
|
echo " --nips=1,5,6,19 Force specific NIPs (comma-separated)"
|
|
echo " --nips=all Include all available NIPs"
|
|
echo " --tests Build all test programs in tests/ directory"
|
|
echo " --verbose, -v Verbose output"
|
|
echo " --help, -h Show this help"
|
|
echo ""
|
|
echo "Auto-Detection:"
|
|
echo " Script automatically scans your .c files for #include statements"
|
|
echo " like #include \"nip001.h\" and compiles only needed NIPs."
|
|
echo ""
|
|
echo "Available NIPs:"
|
|
echo " 001 - Basic Protocol (event creation, signing)"
|
|
echo " 005 - DNS-based identifiers"
|
|
echo " 006 - Key derivation from mnemonic"
|
|
echo " 011 - Relay information document"
|
|
echo " 013 - Proof of Work"
|
|
echo " 019 - Bech32 encoding (nsec/npub)"
|
|
echo " 044 - Encryption"
|
|
echo ""
|
|
echo "Examples:"
|
|
echo " $0 # Auto-detect NIPs, build for current arch"
|
|
echo " $0 x64 # Auto-detect NIPs, build for x64"
|
|
echo " $0 --nips=1,6,19 # Force NIPs 1,6,19 only"
|
|
echo " $0 arm64 --nips=all # Build all NIPs for ARM64"
|
|
exit 0
|
|
fi
|
|
|
|
print_info "NOSTR Core Library - Customer Build Script"
|
|
print_info "Auto-detecting needed NIPs from your source code..."
|
|
|
|
# Detect NIPs from source files
|
|
NEEDED_NIPS=""
|
|
if [ -n "$FORCE_NIPS" ]; then
|
|
if [ "$FORCE_NIPS" = "all" ]; then
|
|
NEEDED_NIPS="001 005 006 011 013 019 044"
|
|
print_info "Forced: Building all available NIPs"
|
|
else
|
|
# Convert comma-separated list to space-separated with 3-digit format
|
|
NEEDED_NIPS=$(echo "$FORCE_NIPS" | tr ',' ' ' | sed 's/\b\([0-9]\)\b/00\1/g' | sed 's/\b\([0-9][0-9]\)\b/0\1/g')
|
|
print_info "Forced NIPs: $NEEDED_NIPS"
|
|
fi
|
|
else
|
|
# Auto-detect from .c files in current directory
|
|
if ls *.c >/dev/null 2>&1; then
|
|
# Scan for nip*.h includes (with or without nostr_core/ prefix)
|
|
DETECTED=$(grep -h '#include[[:space:]]*["\<]\(nostr_core/\)\?nip[0-9][0-9][0-9]\.h["\>]' *.c 2>/dev/null | \
|
|
sed 's/.*nip0*\([0-9]*\)\.h.*/\1/' | \
|
|
sort -u | \
|
|
sed 's/\b\([0-9]\)\b/00\1/g' | sed 's/\b\([0-9][0-9]\)\b/0\1/g')
|
|
|
|
# Check for nostr_core.h (includes everything)
|
|
if grep -q '#include[[:space:]]*["\<]nostr_core\.h["\>]' *.c 2>/dev/null; then
|
|
print_info "Found #include \"nostr_core.h\" - building all NIPs"
|
|
NEEDED_NIPS="001 005 006 011 013 019 044"
|
|
elif [ -n "$DETECTED" ]; then
|
|
NEEDED_NIPS="$DETECTED"
|
|
print_success "Auto-detected NIPs: $(echo $NEEDED_NIPS | tr ' ' ',')"
|
|
else
|
|
print_warning "No NIP includes detected in *.c files"
|
|
print_info "Defaulting to basic NIPs: 001, 006, 019"
|
|
NEEDED_NIPS="001 006 019"
|
|
fi
|
|
else
|
|
print_warning "No .c files found in current directory"
|
|
print_info "Defaulting to basic NIPs: 001, 006, 019"
|
|
NEEDED_NIPS="001 006 019"
|
|
fi
|
|
fi
|
|
|
|
# Ensure NIP-001 is always included (required for core functionality)
|
|
if ! echo "$NEEDED_NIPS" | grep -q "001"; then
|
|
NEEDED_NIPS="001 $NEEDED_NIPS"
|
|
print_info "Added NIP-001 (required for core functionality)"
|
|
fi
|
|
|
|
# Determine architecture
|
|
if [ -z "$ARCHITECTURE" ]; then
|
|
ARCH=$(uname -m)
|
|
case $ARCH in
|
|
x86_64|amd64)
|
|
ARCHITECTURE="x64"
|
|
;;
|
|
aarch64|arm64)
|
|
ARCHITECTURE="arm64"
|
|
;;
|
|
*)
|
|
ARCHITECTURE="x64" # Default fallback
|
|
print_warning "Unknown architecture '$ARCH', defaulting to x64"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
print_info "Target architecture: $ARCHITECTURE"
|
|
|
|
# Set compiler based on architecture
|
|
case $ARCHITECTURE in
|
|
x64)
|
|
CC="gcc"
|
|
ARCH_SUFFIX="x64"
|
|
;;
|
|
arm64)
|
|
CC="aarch64-linux-gnu-gcc"
|
|
ARCH_SUFFIX="arm64"
|
|
;;
|
|
*)
|
|
print_error "Unsupported architecture: $ARCHITECTURE"
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
# Check if compiler exists
|
|
if ! command -v $CC &> /dev/null; then
|
|
print_error "Compiler $CC not found"
|
|
if [ "$ARCHITECTURE" = "arm64" ]; then
|
|
print_info "Install ARM64 cross-compiler: sudo apt install gcc-aarch64-linux-gnu"
|
|
fi
|
|
exit 1
|
|
fi
|
|
|
|
# Build source file list - Core crypto dependencies
|
|
SOURCES="nostr_core/crypto/nostr_crypto.c"
|
|
SOURCES="$SOURCES nostr_core/crypto/nostr_secp256k1.c"
|
|
SOURCES="$SOURCES nostr_core/crypto/nostr_aes.c"
|
|
SOURCES="$SOURCES nostr_core/crypto/nostr_chacha20.c"
|
|
SOURCES="$SOURCES cjson/cJSON.c"
|
|
SOURCES="$SOURCES nostr_core/utils.c"
|
|
|
|
# Add secp256k1 library path based on architecture
|
|
case $ARCHITECTURE in
|
|
x64)
|
|
SECP256K1_LIB="secp256k1/.libs/libsecp256k1.a"
|
|
;;
|
|
arm64)
|
|
SECP256K1_LIB="secp256k1/.libs/libsecp256k1_arm64.a"
|
|
;;
|
|
esac
|
|
NIP_DESCRIPTIONS=""
|
|
|
|
for nip in $NEEDED_NIPS; do
|
|
NIP_FILE="nostr_core/nip${nip}.c"
|
|
if [ -f "$NIP_FILE" ]; then
|
|
SOURCES="$SOURCES $NIP_FILE"
|
|
case $nip in
|
|
001) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-001(Basic)" ;;
|
|
005) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-005(DNS)" ;;
|
|
006) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-006(Keys)" ;;
|
|
011) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-011(Relay-Info)" ;;
|
|
013) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-013(PoW)" ;;
|
|
019) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-019(Bech32)" ;;
|
|
044) NIP_DESCRIPTIONS="$NIP_DESCRIPTIONS NIP-044(Encrypt)" ;;
|
|
esac
|
|
else
|
|
print_warning "NIP file not found: $NIP_FILE - skipping"
|
|
fi
|
|
done
|
|
|
|
# Build flags
|
|
CFLAGS="-Wall -Wextra -std=c99 -fPIC -O2"
|
|
CFLAGS="$CFLAGS -DENABLE_FILE_LOGGING -DENABLE_WEBSOCKET_LOGGING -DENABLE_DEBUG_LOGGING"
|
|
INCLUDES="-I. -Inostr_core -Inostr_core/crypto -Icjson -Isecp256k1/include -Inostr_websocket"
|
|
INCLUDES="$INCLUDES -I./openssl-install/include -I./curl-install/include"
|
|
|
|
# Static libraries
|
|
STATIC_LIBS="./openssl-install/lib64/libssl.a ./openssl-install/lib64/libcrypto.a"
|
|
STATIC_LIBS="$STATIC_LIBS ./curl-install/lib/libcurl.a"
|
|
|
|
# Output library name
|
|
OUTPUT="libnostr_core_${ARCH_SUFFIX}.a"
|
|
|
|
print_info "Compiling with: $CC"
|
|
print_info "Including:$NIP_DESCRIPTIONS"
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Sources: $SOURCES"
|
|
print_info "Flags: $CFLAGS $INCLUDES"
|
|
fi
|
|
|
|
# Compile each source file to object file
|
|
OBJECTS=""
|
|
for source in $SOURCES; do
|
|
if [ -f "$source" ]; then
|
|
obj_name=$(basename "$source" .c).${ARCH_SUFFIX}.o
|
|
OBJECTS="$OBJECTS $obj_name"
|
|
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Compiling: $source -> $obj_name"
|
|
fi
|
|
|
|
$CC $CFLAGS $INCLUDES -c "$source" -o "$obj_name"
|
|
if [ $? -ne 0 ]; then
|
|
print_error "Failed to compile $source"
|
|
exit 1
|
|
fi
|
|
else
|
|
print_error "Source file not found: $source"
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
# Create self-contained static library (extract all objects first)
|
|
print_info "Creating self-contained static library: $OUTPUT"
|
|
|
|
# Create temporary directories for extracting objects
|
|
TMP_SECP256K1=".tmp_secp256k1_$$"
|
|
TMP_OPENSSL=".tmp_openssl_$$"
|
|
TMP_CURL=".tmp_curl_$$"
|
|
|
|
mkdir -p "$TMP_SECP256K1" "$TMP_OPENSSL" "$TMP_CURL"
|
|
|
|
# Extract secp256k1 objects
|
|
if [ -f "$SECP256K1_LIB" ]; then
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Extracting secp256k1 objects..."
|
|
fi
|
|
(cd "$TMP_SECP256K1" && ar x "../$SECP256K1_LIB")
|
|
fi
|
|
|
|
# Extract OpenSSL objects
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Extracting OpenSSL objects..."
|
|
fi
|
|
(cd "$TMP_OPENSSL" && ar x "../openssl-install/lib64/libssl.a")
|
|
(cd "$TMP_OPENSSL" && ar x "../openssl-install/lib64/libcrypto.a")
|
|
|
|
# Extract curl objects
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Extracting curl objects..."
|
|
fi
|
|
(cd "$TMP_CURL" && ar x "../curl-install/lib/libcurl.a")
|
|
|
|
# Combine all objects into final library
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info "Combining all objects into self-contained library..."
|
|
fi
|
|
ar rcs "$OUTPUT" $OBJECTS "$TMP_SECP256K1"/*.o "$TMP_OPENSSL"/*.o "$TMP_CURL"/*.o 2>/dev/null
|
|
|
|
# Cleanup temporary directories
|
|
rm -rf "$TMP_SECP256K1" "$TMP_OPENSSL" "$TMP_CURL"
|
|
|
|
if [ $? -eq 0 ]; then
|
|
# Cleanup object files
|
|
rm -f $OBJECTS
|
|
|
|
# Show library info
|
|
size_kb=$(du -k "$OUTPUT" | cut -f1)
|
|
print_success "Built $OUTPUT (${size_kb}KB) with:$NIP_DESCRIPTIONS"
|
|
|
|
# Build tests if requested
|
|
if [ "$BUILD_TESTS" = true ]; then
|
|
print_info "Scanning tests/ directory for test programs..."
|
|
|
|
if [ ! -d "tests" ]; then
|
|
print_warning "tests/ directory not found - skipping test builds"
|
|
else
|
|
TEST_COUNT=0
|
|
SUCCESS_COUNT=0
|
|
|
|
# Find all .c files in tests/ directory (not subdirectories)
|
|
while IFS= read -r -d '' test_file; do
|
|
TEST_COUNT=$((TEST_COUNT + 1))
|
|
test_name=$(basename "$test_file" .c)
|
|
test_exe="tests/$test_name"
|
|
|
|
print_info "Building test: $test_name"
|
|
|
|
# Determine linking requirements based on file content
|
|
LINK_FLAGS="-lm -static"
|
|
|
|
# Always include secp256k1 library if available
|
|
if [ -f "$SECP256K1_LIB" ]; then
|
|
LINK_FLAGS="$SECP256K1_LIB $LINK_FLAGS"
|
|
fi
|
|
|
|
# Check if test needs curl/SSL libraries (NIP-05/NIP-11)
|
|
if grep -q -E 'nip005|nip011|curl/curl\.h' "$test_file" 2>/dev/null; then
|
|
# Check if curl and SSL libraries are available
|
|
if [ -f "./curl-install/lib/libcurl.a" ] && [ -f "./openssl-install/lib64/libssl.a" ]; then
|
|
LINK_FLAGS="./curl-install/lib/libcurl.a ./openssl-install/lib64/libssl.a ./openssl-install/lib64/libcrypto.a -lz -ldl -lpthread $LINK_FLAGS"
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info " Using full static SSL/curl linking for $test_name"
|
|
fi
|
|
else
|
|
print_warning " Test $test_name needs curl/SSL but libraries not found - using basic linking"
|
|
fi
|
|
fi
|
|
|
|
# Compile the test
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_info " Command: $CC $CFLAGS $INCLUDES \"$test_file\" -o \"$test_exe\" ./$OUTPUT $LINK_FLAGS"
|
|
fi
|
|
|
|
if $CC $CFLAGS $INCLUDES "$test_file" -o "$test_exe" "./$OUTPUT" $LINK_FLAGS 2>/dev/null; then
|
|
SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
|
|
if [ "$VERBOSE" = true ]; then
|
|
print_success " Built: $test_exe"
|
|
fi
|
|
else
|
|
print_error " Failed to build: $test_name"
|
|
fi
|
|
|
|
done < <(find tests/ -maxdepth 1 -name "*.c" -type f -print0)
|
|
|
|
if [ $TEST_COUNT -eq 0 ]; then
|
|
print_warning "No .c files found in tests/ directory"
|
|
else
|
|
print_success "Built $SUCCESS_COUNT/$TEST_COUNT test programs"
|
|
fi
|
|
fi
|
|
echo ""
|
|
fi
|
|
|
|
echo "Usage in your project:"
|
|
echo " gcc your_app.c $OUTPUT -lz -ldl -lpthread -o your_app"
|
|
echo ""
|
|
else
|
|
print_error "Failed to create static library"
|
|
exit 1
|
|
fi
|