fix: restore [ips_fixed] to use addFixedPeer instead of addFallbackStrings

Commit c65a0332bc refactored IP handling but accidentally broke [ips_fixed]
by treating fixed peers as regular bootstrap sources. This caused fixed
peers to not bypass slot limits, breaking connectivity for nodes with low
peers_max values.

This fix does NOT restore:
- The fallback behavior where [ips_fixed] was used as bootstrap when [ips]
  was empty (added in 98bdb9de68, 2015)
- Any hardcoded default bootstrap IPs

These are unnecessary because addFixedPeer actively maintains connections
to fixed peers regardless of the bootstrap mechanism. Nodes with only
[ips_fixed] configured will still connect and discover peers through
their fixed connections.

Closes #636

.github/actions/xahau-configure-ccache/action.yml

@@ -0,0 +1,63 @@
+name: 'Configure ccache'
+description: 'Sets up ccache with consistent configuration'
+
+inputs:
+  max_size:
+    description: 'Maximum cache size'
+    required: false
+    default: '2G'
+  hash_dir:
+    description: 'Whether to include directory paths in hash'
+    required: false
+    default: 'true'
+  compiler_check:
+    description: 'How to check compiler for changes'
+    required: false
+    default: 'content'
+  is_main_branch:
+    description: 'Whether the current branch is the main branch'
+    required: false
+    default: 'false'
+  main_cache_dir:
+    description: 'Path to the main branch cache directory'
+    required: false
+    default: '~/.ccache-main'
+  current_cache_dir:
+    description: 'Path to the current branch cache directory'
+    required: false
+    default: '~/.ccache-current'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Configure ccache
+      shell: bash
+      run: |
+        # Create cache directories
+        mkdir -p ${{ inputs.main_cache_dir }} ${{ inputs.current_cache_dir }}
+        
+        # Set compiler check globally
+        ccache -o compiler_check=${{ inputs.compiler_check }}
+        
+        # Use a single config file location
+        mkdir -p ~/.ccache
+        export CONF_PATH="$HOME/.ccache/ccache.conf"
+        
+        # Apply common settings
+        echo "max_size = ${{ inputs.max_size }}" > "$CONF_PATH"
+        echo "hash_dir = ${{ inputs.hash_dir }}" >> "$CONF_PATH"
+        echo "compiler_check = ${{ inputs.compiler_check }}" >> "$CONF_PATH"
+        
+        if [ "${{ inputs.is_main_branch }}" == "true" ]; then
+          # Main branch: use main branch cache
+          ccache --set-config=cache_dir="${{ inputs.main_cache_dir }}"
+          echo "CCACHE_DIR=${{ inputs.main_cache_dir }}" >> $GITHUB_ENV
+        else
+          # Feature branch: use current branch cache with main as secondary
+          ccache --set-config=cache_dir="${{ inputs.current_cache_dir }}"
+          ccache --set-config=secondary_storage="file:${{ inputs.main_cache_dir }}"
+          echo "CCACHE_DIR=${{ inputs.current_cache_dir }}" >> $GITHUB_ENV
+        fi
+        
+        ccache -p # Print config for verification
+        ccache -z # Zero statistics before the build

.github/actions/xahau-ga-build/action.yml

@@ -47,18 +47,6 @@ inputs:
     description: 'GCC version to use for Clang toolchain (e.g. 11, 13)'
     required: false
     default: ''
-  ccache_max_size:
-    description: 'Maximum ccache size'
-    required: false
-    default: '2G'
-  ccache_hash_dir:
-    description: 'Whether to include directory paths in hash'
-    required: false
-    default: 'true'
-  ccache_compiler_check:
-    description: 'How to check compiler for changes'
-    required: false
-    default: 'content'
 
 runs:
   using: 'composite'
@@ -71,22 +59,21 @@ runs:
         SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
         echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
 
-    - name: Restore ccache directory for main branch
+    - name: Restore ccache directory for default branch
       if: inputs.ccache_enabled == 'true'
       id: ccache-restore
-      uses: ./.github/actions/xahau-ga-cache-restore
+      uses: actions/cache/restore@v4
       with:
         path: ~/.ccache-main
         key: ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
         restore-keys: |
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
-        cache-type: ccache-main
 
     - name: Restore ccache directory for current branch
       if: inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name != inputs.main_branch
       id: ccache-restore-current-branch
-      uses: ./.github/actions/xahau-ga-cache-restore
+      uses: actions/cache/restore@v4
       with:
         path: ~/.ccache-current
         key: ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ steps.safe-branch.outputs.name }}
@@ -94,40 +81,6 @@ runs:
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
-        cache-type: ccache-current
-
-    - name: Configure ccache
-      if: inputs.ccache_enabled == 'true'
-      shell: bash
-      run: |
-        # Create cache directories
-        mkdir -p ~/.ccache-main ~/.ccache-current
-
-        # Configure ccache settings AFTER cache restore (prevents stale cached config)
-        ccache --set-config=max_size=${{ inputs.ccache_max_size }}
-        ccache --set-config=hash_dir=${{ inputs.ccache_hash_dir }}
-        ccache --set-config=compiler_check=${{ inputs.ccache_compiler_check }}
-
-        # Determine if we're on the main branch
-        if [ "${{ steps.safe-branch.outputs.name }}" = "${{ inputs.main_branch }}" ]; then
-          # Main branch: use main branch cache only
-          ccache --set-config=cache_dir="$HOME/.ccache-main"
-          echo "CCACHE_DIR=$HOME/.ccache-main" >> $GITHUB_ENV
-          echo "📦 Main branch: using ~/.ccache-main"
-        else
-          # Feature branch: use current branch cache with main as secondary (read-only fallback)
-          ccache --set-config=cache_dir="$HOME/.ccache-current"
-          ccache --set-config=secondary_storage="file:$HOME/.ccache-main"
-          echo "CCACHE_DIR=$HOME/.ccache-current" >> $GITHUB_ENV
-          echo "📦 Feature branch: using ~/.ccache-current with ~/.ccache-main as secondary"
-        fi
-
-        # Print config for verification
-        echo "=== ccache configuration ==="
-        ccache -p
-
-        # Zero statistics before the build
-        ccache -z
 
     - name: Configure project
       shell: bash
@@ -143,27 +96,14 @@ runs:
         if [ -n "${{ inputs.cxx }}" ]; then
           export CXX="${{ inputs.cxx }}"
         fi
-
+        
-        # Create wrapper toolchain that overlays ccache on top of Conan's toolchain
+        
-        # This enables ccache for the main app build without affecting Conan dependency builds
+        # Configure ccache launcher args
+        CCACHE_ARGS=""
         if [ "${{ inputs.ccache_enabled }}" = "true" ]; then
-          cat > wrapper_toolchain.cmake <<'EOF'
+          CCACHE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
-        # Include Conan's generated toolchain first (sets compiler, flags, etc.)
-        # Note: CMAKE_CURRENT_LIST_DIR is the directory containing this wrapper (.build/)
-        include(${CMAKE_CURRENT_LIST_DIR}/build/generators/conan_toolchain.cmake)
-
-        # Overlay ccache configuration for main application build
-        # This does NOT affect Conan dependency builds (already completed)
-        set(CMAKE_C_COMPILER_LAUNCHER ccache CACHE STRING "C compiler launcher" FORCE)
-        set(CMAKE_CXX_COMPILER_LAUNCHER ccache CACHE STRING "C++ compiler launcher" FORCE)
-        EOF
-          TOOLCHAIN_FILE="wrapper_toolchain.cmake"
-          echo "✅ Created wrapper toolchain with ccache enabled"
-        else
-          TOOLCHAIN_FILE="build/generators/conan_toolchain.cmake"
-          echo "ℹ️  Using Conan toolchain directly (ccache disabled)"
         fi
-
+        
         # Configure C++ standard library if specified
         # libstdcxx used for clang-14/16 to work around missing lexicographical_compare_three_way in libc++
         # libcxx can be used with clang-17+ which has full C++20 support
@@ -203,48 +143,31 @@ runs:
         # So we get: .build/build/generators/ with our non-standard folder name
         cmake .. \
           -G "${{ inputs.generator }}" \
+          $CCACHE_ARGS \
           ${CMAKE_CXX_FLAGS:+-DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS"} \
-          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${TOOLCHAIN_FILE} \
+          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
           -DCMAKE_BUILD_TYPE=${{ inputs.configuration }}
 
-    - name: Show ccache config before build
-      if: inputs.ccache_enabled == 'true'
-      shell: bash
-      run: |
-        echo "=========================================="
-        echo "ccache configuration before build"
-        echo "=========================================="
-        ccache -p
-        echo ""
-
     - name: Build project
       shell: bash
       run: |
         cd ${{ inputs.build_dir }}
-
+        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc)
-        # Check for verbose build flag in commit message
-        VERBOSE_FLAG=""
-        if echo "${XAHAU_GA_COMMIT_MSG}" | grep -q '\[ci-ga-cmake-verbose\]'; then
-          echo "🔊 [ci-ga-cmake-verbose] detected - enabling verbose output"
-          VERBOSE_FLAG="-- -v"
-        fi
-
-        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc) ${VERBOSE_FLAG}
 
     - name: Show ccache statistics
       if: inputs.ccache_enabled == 'true'
       shell: bash
       run: ccache -s
 
-    - name: Save ccache directory for main branch
+    - name: Save ccache directory for default branch
-      if: success() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name == inputs.main_branch
+      if: always() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name == inputs.main_branch
       uses: actions/cache/save@v4
       with:
         path: ~/.ccache-main
         key: ${{ steps.ccache-restore.outputs.cache-primary-key }}
 
     - name: Save ccache directory for current branch
-      if: success() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name != inputs.main_branch
+      if: always() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name != inputs.main_branch
       uses: actions/cache/save@v4
       with:
         path: ~/.ccache-current

.github/actions/xahau-ga-cache-restore/action.yml

@@ -1,146 +0,0 @@
-name: 'Cache Restore'
-description: 'Restores cache with optional clearing based on commit message tags'
-
-inputs:
-  path:
-    description: 'A list of files, directories, and wildcard patterns to cache'
-    required: true
-  key:
-    description: 'An explicit key for restoring the cache'
-    required: true
-  restore-keys:
-    description: 'An ordered list of prefix-matched keys to use for restoring stale cache if no cache hit occurred for key'
-    required: false
-    default: ''
-  cache-type:
-    description: 'Type of cache (for logging purposes, e.g., "ccache-main", "Conan")'
-    required: false
-    default: 'cache'
-  fail-on-cache-miss:
-    description: 'Fail the workflow if cache entry is not found'
-    required: false
-    default: 'false'
-  lookup-only:
-    description: 'Check if a cache entry exists for the given input(s) without downloading it'
-    required: false
-    default: 'false'
-  additional-clear-keys:
-    description: 'Additional cache keys to clear (newline separated)'
-    required: false
-    default: ''
-
-outputs:
-  cache-hit:
-    description: 'A boolean value to indicate an exact match was found for the primary key'
-    value: ${{ steps.restore-cache.outputs.cache-hit }}
-  cache-primary-key:
-    description: 'The key that was used to restore the cache'
-    value: ${{ steps.restore-cache.outputs.cache-primary-key }}
-  cache-matched-key:
-    description: 'The key that was used to restore the cache (exact or prefix match)'
-    value: ${{ steps.restore-cache.outputs.cache-matched-key }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Clear cache if requested via commit message
-      shell: bash
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        echo "=========================================="
-        echo "${{ inputs.cache-type }} cache clear tag detection"
-        echo "=========================================="
-        echo "Searching for: [ci-ga-clear-cache] or [ci-ga-clear-cache:*]"
-        echo ""
-
-        CACHE_KEY="${{ inputs.key }}"
-
-        # Extract search terms if present (e.g., "ccache" from "[ci-ga-clear-cache:ccache]")
-        SEARCH_TERMS=$(echo "${XAHAU_GA_COMMIT_MSG}" | grep -o '\[ci-ga-clear-cache:[^]]*\]' | sed 's/\[ci-ga-clear-cache://;s/\]//' || echo "")
-
-        SHOULD_CLEAR=false
-
-        if [ -n "${SEARCH_TERMS}" ]; then
-          # Search terms provided - check if THIS cache key matches ALL terms (AND logic)
-          echo "🔍 [ci-ga-clear-cache:${SEARCH_TERMS}] detected"
-          echo "Checking if cache key matches search terms..."
-          echo "  Cache key: ${CACHE_KEY}"
-          echo "  Search terms: ${SEARCH_TERMS}"
-          echo ""
-
-          MATCHES=true
-          for term in ${SEARCH_TERMS}; do
-            if ! echo "${CACHE_KEY}" | grep -q "${term}"; then
-              MATCHES=false
-              echo "  ✗ Key does not contain '${term}'"
-              break
-            else
-              echo "  ✓ Key contains '${term}'"
-            fi
-          done
-
-          if [ "${MATCHES}" = "true" ]; then
-            echo ""
-            echo "✅ Cache key matches all search terms - will clear cache"
-            SHOULD_CLEAR=true
-          else
-            echo ""
-            echo "⏭️  Cache key doesn't match search terms - skipping cache clear"
-          fi
-        elif echo "${XAHAU_GA_COMMIT_MSG}" | grep -q '\[ci-ga-clear-cache\]'; then
-          # No search terms - always clear this job's cache
-          echo "🗑️  [ci-ga-clear-cache] detected in commit message"
-          echo "Clearing ${{ inputs.cache-type }} cache for key: ${CACHE_KEY}"
-          SHOULD_CLEAR=true
-        fi
-
-        if [ "${SHOULD_CLEAR}" = "true" ]; then
-          echo ""
-          echo "Deleting ${{ inputs.cache-type }} caches via GitHub API..."
-
-          # Delete primary cache key
-          echo "Checking for cache: ${CACHE_KEY}"
-          if gh cache list --key "${CACHE_KEY}" --json key --jq '.[].key' | grep -q "${CACHE_KEY}"; then
-            echo "  Deleting: ${CACHE_KEY}"
-            gh cache delete "${CACHE_KEY}" || true
-            echo "  ✓ Deleted"
-          else
-            echo "  ℹ️  Not found"
-          fi
-
-          # Delete additional keys if provided
-          if [ -n "${{ inputs.additional-clear-keys }}" ]; then
-            echo ""
-            echo "Checking additional keys..."
-            while IFS= read -r key; do
-              [ -z "${key}" ] && continue
-              echo "Checking for cache: ${key}"
-              if gh cache list --key "${key}" --json key --jq '.[].key' | grep -q "${key}"; then
-                echo "  Deleting: ${key}"
-                gh cache delete "${key}" || true
-                echo "  ✓ Deleted"
-              else
-                echo "  ℹ️  Not found"
-              fi
-            done <<< "${{ inputs.additional-clear-keys }}"
-          fi
-
-          echo ""
-          echo "✅ ${{ inputs.cache-type }} cache cleared successfully"
-          echo "Build will proceed from scratch"
-        else
-          echo ""
-          echo "ℹ️  No ${{ inputs.cache-type }} cache clear requested"
-        fi
-        echo "=========================================="
-
-    - name: Restore cache
-      id: restore-cache
-      uses: actions/cache/restore@v4
-      with:
-        path: ${{ inputs.path }}
-        key: ${{ inputs.key }}
-        restore-keys: ${{ inputs.restore-keys }}
-        fail-on-cache-miss: ${{ inputs.fail-on-cache-miss }}
-        lookup-only: ${{ inputs.lookup-only }}

.github/actions/xahau-ga-dependencies/action.yml

@@ -25,28 +25,6 @@ inputs:
     description: 'Main branch name for restore keys'
     required: false
     default: 'dev'
-  os:
-    description: 'Operating system (Linux, Macos)'
-    required: false
-    default: 'Linux'
-  arch:
-    description: 'Architecture (x86_64, armv8)'
-    required: false
-    default: 'x86_64'
-  compiler:
-    description: 'Compiler type (gcc, clang, apple-clang)'
-    required: true
-  compiler_version:
-    description: 'Compiler version (11, 13, 14, etc.)'
-    required: true
-  cc:
-    description: 'C compiler executable (gcc-13, clang-14, etc.), empty for macOS'
-    required: false
-    default: ''
-  cxx:
-    description: 'C++ compiler executable (g++-14, clang++-14, etc.), empty for macOS'
-    required: false
-    default: ''
   stdlib:
     description: 'C++ standard library for Conan configuration (note: also in compiler-id)'
     required: true
@@ -63,70 +41,47 @@ outputs:
 runs:
   using: 'composite'
   steps:
+    - name: Generate safe branch name
+      if: inputs.cache_enabled == 'true'
+      id: safe-branch
+      shell: bash
+      run: |
+        SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
+        echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
+
+    - name: Check conanfile changes
+      if: inputs.cache_enabled == 'true'
+      id: check-conanfile-changes
+      shell: bash
+      run: |
+        # Check if we're on the main branch
+        if [ "${{ github.ref_name }}" == "${{ inputs.main_branch }}" ]; then
+          echo "should-save-conan-cache=true" >> $GITHUB_OUTPUT
+        else
+          # Fetch main branch for comparison
+          git fetch origin ${{ inputs.main_branch }}
+          
+          # Check if conanfile.txt or conanfile.py has changed compared to main branch
+          if git diff --quiet origin/${{ inputs.main_branch }}..HEAD -- '**/conanfile.txt' '**/conanfile.py'; then
+            echo "should-save-conan-cache=false" >> $GITHUB_OUTPUT
+          else
+            echo "should-save-conan-cache=true" >> $GITHUB_OUTPUT
+          fi
+        fi
+
     - name: Restore Conan cache
       if: inputs.cache_enabled == 'true'
       id: cache-restore-conan
-      uses: ./.github/actions/xahau-ga-cache-restore
+      uses: actions/cache/restore@v4
       with:
-        path: ~/.conan2
+        path: |
+          ~/.conan
+          ~/.conan2
         # Note: compiler-id format is compiler-version-stdlib[-gccversion]
-        key: ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.py') }}-${{ inputs.configuration }}
+        key: ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-${{ inputs.configuration }}
         restore-keys: |
-          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.py') }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-
           ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
-        cache-type: Conan
-
-    - name: Configure Conan
-      shell: bash
-      run: |
-        # Create the default profile directory if it doesn't exist
-        mkdir -p ~/.conan2/profiles
-
-        # Determine the correct libcxx based on stdlib parameter
-        if [ "${{ inputs.stdlib }}" = "libcxx" ]; then
-          LIBCXX="libc++"
-        else
-          LIBCXX="libstdc++11"
-        fi
-
-        # Create profile with our specific settings
-        # This overwrites any cached profile to ensure fresh configuration
-        cat > ~/.conan2/profiles/default <<EOF
-        [settings]
-        arch=${{ inputs.arch }}
-        build_type=${{ inputs.configuration }}
-        compiler=${{ inputs.compiler }}
-        compiler.cppstd=20
-        compiler.libcxx=${LIBCXX}
-        compiler.version=${{ inputs.compiler_version }}
-        os=${{ inputs.os }}
-        EOF
-
-        # Add buildenv and conf sections for Linux (not needed for macOS)
-        if [ "${{ inputs.os }}" = "Linux" ] && [ -n "${{ inputs.cc }}" ]; then
-          cat >> ~/.conan2/profiles/default <<EOF
-
-        [buildenv]
-        CC=/usr/bin/${{ inputs.cc }}
-        CXX=/usr/bin/${{ inputs.cxx }}
-
-        [conf]
-        tools.build:compiler_executables={"c": "/usr/bin/${{ inputs.cc }}", "cpp": "/usr/bin/${{ inputs.cxx }}"}
-        EOF
-        fi
-
-        # Add macOS-specific conf if needed
-        if [ "${{ inputs.os }}" = "Macos" ]; then
-          cat >> ~/.conan2/profiles/default <<EOF
-
-        [conf]
-        # Workaround for gRPC with newer Apple Clang
-        tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
-        EOF
-        fi
-
-        # Display profile for verification
-        conan profile show
 
     - name: Export custom recipes
       shell: bash
@@ -152,8 +107,10 @@ runs:
           ..
 
     - name: Save Conan cache
-      if: success() && inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true'
+      if: always() && inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true' && steps.check-conanfile-changes.outputs.should-save-conan-cache == 'true'
       uses: actions/cache/save@v4
       with:
-        path: ~/.conan2
+        path: |
+          ~/.conan
+          ~/.conan2
         key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}

.github/actions/xahau-ga-get-commit-message/action.yml

@@ -1,74 +0,0 @@
-name: 'Get Commit Message'
-description: 'Gets commit message for both push and pull_request events and sets XAHAU_GA_COMMIT_MSG env var'
-
-inputs:
-  event-name:
-    description: 'The event name (push or pull_request)'
-    required: true
-  head-commit-message:
-    description: 'The head commit message (for push events)'
-    required: false
-    default: ''
-  pr-head-sha:
-    description: 'The PR head SHA (for pull_request events)'
-    required: false
-    default: ''
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Get commit message and set environment variable
-      shell: python
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        import json
-        import os
-        import secrets
-        import urllib.request
-
-        event_name = "${{ inputs.event-name }}"
-        pr_head_sha = "${{ inputs.pr-head-sha }}"
-        repository = "${{ github.repository }}"
-
-        print("==========================================")
-        print("Setting XAHAU_GA_COMMIT_MSG environment variable")
-        print("==========================================")
-        print(f"Event: {event_name}")
-
-        if event_name == 'push':
-            # For push events, use the input directly
-            message = """${{ inputs.head-commit-message }}"""
-            print("Source: workflow input (github.event.head_commit.message)")
-        elif event_name == 'pull_request' and pr_head_sha:
-            # For PR events, fetch via GitHub API
-            print(f"Source: GitHub API (fetching commit {pr_head_sha})")
-            try:
-                url = f"https://api.github.com/repos/{repository}/commits/{pr_head_sha}"
-                req = urllib.request.Request(url, headers={
-                    "Accept": "application/vnd.github.v3+json",
-                    "Authorization": f"Bearer {os.environ.get('GH_TOKEN', '')}"
-                })
-                with urllib.request.urlopen(req) as response:
-                    data = json.load(response)
-                    message = data["commit"]["message"]
-            except Exception as e:
-                print(f"Failed to fetch commit message: {e}")
-                message = ""
-        else:
-            message = ""
-            print(f"Warning: Unknown event type: {event_name}")
-
-        print(f"Commit message (first 100 chars): {message[:100]}")
-
-        # Write to GITHUB_ENV using heredoc with random delimiter (prevents injection attacks)
-        # See: https://securitylab.github.com/resources/github-actions-untrusted-input/
-        delimiter = f"EOF_{secrets.token_hex(16)}"
-
-        with open(os.environ['GITHUB_ENV'], 'a') as f:
-            f.write(f'XAHAU_GA_COMMIT_MSG<<{delimiter}\n')
-            f.write(message)
-            f.write(f'\n{delimiter}\n')
-
-        print(f"✓ XAHAU_GA_COMMIT_MSG set (available to all subsequent steps)")
-        print("==========================================")

.github/workflows/xahau-ga-macos.yml

@@ -20,24 +20,16 @@ jobs:
           - Ninja
         configuration:
           - Debug
-    runs-on: macos-15-xlarge
+    runs-on: macos-15
     env:
       build_dir: .build
       # Bump this number to invalidate all caches globally.
-      CACHE_VERSION: 3
+      CACHE_VERSION: 1
       MAIN_BRANCH_NAME: dev
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Get commit message
-        id: get-commit-message
-        uses: ./.github/actions/xahau-ga-get-commit-message
-        with:
-          event-name: ${{ github.event_name }}
-          head-commit-message: ${{ github.event.head_commit.message }}
-          pr-head-sha: ${{ github.event.pull_request.head.sha }}
-
       - name: Install Conan
         run: |
           brew install conan
@@ -86,6 +78,14 @@ jobs:
       - name: Install ccache
         run: brew install ccache
 
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+          is_main_branch: ${{ github.ref_name == env.MAIN_BRANCH_NAME }}
+
       - name: Check environment
         run: |
           echo "PATH:"
@@ -98,12 +98,32 @@ jobs:
           echo "---- Full Environment ----"
           env
 
-      - name: Detect compiler version
+      - name: Configure Conan
-        id: detect-compiler
         run: |
+          # Create the default profile directory if it doesn't exist
+          mkdir -p ~/.conan2/profiles
+
+          # Detect compiler version
           COMPILER_VERSION=$(clang --version | grep -oE 'version [0-9]+' | grep -oE '[0-9]+')
-          echo "compiler_version=${COMPILER_VERSION}" >> $GITHUB_OUTPUT
+
-          echo "Detected Apple Clang version: ${COMPILER_VERSION}"
+          # Create profile with our specific settings
+          cat > ~/.conan2/profiles/default <<EOF
+          [settings]
+          arch=armv8
+          build_type=Release
+          compiler=apple-clang
+          compiler.cppstd=20
+          compiler.libcxx=libc++
+          compiler.version=${COMPILER_VERSION}
+          os=Macos
+
+          [conf]
+          # Workaround for gRPC with newer Apple Clang
+          tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
+          EOF
+
+          # Display profile for verification
+          conan profile show
 
       - name: Install dependencies
         uses: ./.github/actions/xahau-ga-dependencies
@@ -113,11 +133,6 @@ jobs:
           compiler-id: clang
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
-          os: Macos
-          arch: armv8
-          compiler: apple-clang
-          compiler_version: ${{ steps.detect-compiler.outputs.compiler_version }}
-          stdlib: libcxx
 
       - name: Build
         uses: ./.github/actions/xahau-ga-build
@@ -128,7 +143,6 @@ jobs:
           compiler-id: clang
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
-          stdlib: libcxx
 
       - name: Test
         run: |

.github/workflows/xahau-ga-nix.yml

@@ -22,13 +22,10 @@ jobs:
       - name: Generate build matrix
         id: set-matrix
         shell: python
-        env:
-          GH_TOKEN: ${{ github.token }}
         run: |
           import json
           import os
-          import urllib.request
+          
-
           # Full matrix with all 6 compiler configurations
           # Each configuration includes all parameters needed by the build job
           full_matrix = [
@@ -102,31 +99,13 @@ jobs:
           ref = "${{ github.ref }}"
           base_ref = "${{ github.base_ref }}"  # For PRs, this is the target branch
           event_name = "${{ github.event_name }}"
+          commit_message = """${{ github.event.head_commit.message }}"""
           pr_title = """${{ github.event.pull_request.title }}"""
-          pr_head_sha = "${{ github.event.pull_request.head.sha }}"
+          
-
-          # Get commit message - for PRs, fetch via API since head_commit.message is empty
-          if event_name == "pull_request" and pr_head_sha:
-              try:
-                  url = f"https://api.github.com/repos/${{ github.repository }}/commits/{pr_head_sha}"
-                  req = urllib.request.Request(url, headers={
-                      "Accept": "application/vnd.github.v3+json",
-                      "Authorization": f"Bearer {os.environ.get('GH_TOKEN', '')}"
-                  })
-                  with urllib.request.urlopen(req) as response:
-                      data = json.load(response)
-                      commit_message = data["commit"]["message"]
-              except Exception as e:
-                  print(f"Failed to fetch commit message: {e}")
-                  commit_message = ""
-          else:
-              commit_message = """${{ github.event.head_commit.message }}"""
-
           # Debug logging
           print(f"Event: {event_name}")
           print(f"Ref: {ref}")
           print(f"Base ref: {base_ref}")
-          print(f"PR head SHA: {pr_head_sha}")
           print(f"PR title: {pr_title}")
           print(f"Commit message: {commit_message}")
           
@@ -177,20 +156,12 @@ jobs:
     env:
       build_dir: .build
       # Bump this number to invalidate all caches globally.
-      CACHE_VERSION: 3
+      CACHE_VERSION: 2
       MAIN_BRANCH_NAME: dev
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Get commit message
-        id: get-commit-message
-        uses: ./.github/actions/xahau-ga-get-commit-message
-        with:
-          event-name: ${{ github.event_name }}
-          head-commit-message: ${{ github.event.head_commit.message }}
-          pr-head-sha: ${{ github.event.pull_request.head.sha }}
-
       - name: Install build dependencies
         run: |
           sudo apt-get update
@@ -260,6 +231,48 @@ jobs:
           # Install Conan 2
           pip install --upgrade "conan>=2.0,<3"
 
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+          is_main_branch: ${{ github.ref_name == env.MAIN_BRANCH_NAME }}
+
+      - name: Configure Conan
+        run: |
+          # Create the default profile directory if it doesn't exist
+          mkdir -p ~/.conan2/profiles
+
+          # Determine the correct libcxx based on stdlib parameter
+          if [ "${{ matrix.stdlib }}" = "libcxx" ]; then
+            LIBCXX="libc++"
+          else
+            LIBCXX="libstdc++11"
+          fi
+
+          # Create profile with our specific settings
+          cat > ~/.conan2/profiles/default <<EOF
+          [settings]
+          arch=x86_64
+          build_type=${{ matrix.configuration }}
+          compiler=${{ matrix.compiler }}
+          compiler.cppstd=20
+          compiler.libcxx=${LIBCXX}
+          compiler.version=${{ matrix.compiler_version }}
+          os=Linux
+
+          [buildenv]
+          CC=/usr/bin/${{ matrix.cc }}
+          CXX=/usr/bin/${{ matrix.cxx }}
+
+          [conf]
+          tools.build:compiler_executables={"c": "/usr/bin/${{ matrix.cc }}", "cpp": "/usr/bin/${{ matrix.cxx }}"}
+          EOF
+
+          # Display profile for verification
+          conan profile show
+
       - name: Check environment
         run: |
           echo "PATH:"
@@ -280,10 +293,6 @@ jobs:
           compiler-id: ${{ matrix.compiler_id }}
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
-          compiler: ${{ matrix.compiler }}
-          compiler_version: ${{ matrix.compiler_version }}
-          cc: ${{ matrix.cc }}
-          cxx: ${{ matrix.cxx }}
           stdlib: ${{ matrix.stdlib }}
 
       - name: Build

src/ripple/overlay/impl/OverlayImpl.cpp

@@ -484,44 +484,61 @@ OverlayImpl::start()
     m_peerFinder->setConfig(config);
     m_peerFinder->start();
 
-    auto addIps = [&](std::vector<std::string> bootstrapIps) -> void {
+    auto addIps = [this](std::vector<std::string> ips, bool fixed) {
         beast::Journal const& j = app_.journal("Overlay");
-        for (auto& ip : bootstrapIps)
+        for (auto& ip : ips)
         {
             std::size_t pos = ip.find('#');
             if (pos != std::string::npos)
                 ip.erase(pos);
 
-            JLOG(j.trace()) << "Found boostrap IP: " << ip;
+            JLOG(j.trace())
+                << "Found " << (fixed ? "fixed" : "bootstrap") << " IP: " << ip;
         }
 
         m_resolver.resolve(
-            bootstrapIps,
+            ips,
-            [&](std::string const& name,
+            [this, fixed](
+                std::string const& name,
                 std::vector<beast::IP::Endpoint> const& addresses) {
-                std::vector<std::string> ips;
-                ips.reserve(addresses.size());
                 beast::Journal const& j = app_.journal("Overlay");
+                std::string const base("config: ");
+
+                std::vector<beast::IP::Endpoint> eps;
+                eps.reserve(addresses.size());
                 for (auto const& addr : addresses)
                 {
-                    std::string addrStr = addr.port() == 0
+                    auto ep = addr.port() == 0 ? addr.at_port(DEFAULT_PEER_PORT)
-                        ? to_string(addr.at_port(DEFAULT_PEER_PORT))
+                                               : addr;
-                        : to_string(addr);
+                    JLOG(j.trace())
-                    JLOG(j.trace()) << "Parsed boostrap IP: " << addrStr;
+                        << "Parsed " << (fixed ? "fixed" : "bootstrap")
-                    ips.push_back(addrStr);
+                        << " IP: " << ep;
+                    eps.push_back(ep);
                 }
 
-                std::string const base("config: ");
+                if (eps.empty())
-                if (!ips.empty())
+                    return;
-                    m_peerFinder->addFallbackStrings(base + name, ips);
+
+                if (fixed)
+                {
+                    m_peerFinder->addFixedPeer(base + name, eps);
+                }
+                else
+                {
+                    std::vector<std::string> strs;
+                    strs.reserve(eps.size());
+                    for (auto const& ep : eps)
+                        strs.push_back(to_string(ep));
+                    m_peerFinder->addFallbackStrings(base + name, strs);
+                }
             });
     };
 
     if (!app_.config().IPS.empty())
-        addIps(app_.config().IPS);
+        addIps(app_.config().IPS, false);
 
     if (!app_.config().IPS_FIXED.empty())
-        addIps(app_.config().IPS_FIXED);
+        addIps(app_.config().IPS_FIXED, true);
 
     auto const timer = std::make_shared<Timer>(*this);
     std::lock_guard lock(mutex_);