base_node_binaries.yml

---
name: Build Matrix of Binaries

'on':
  push:
    tags:
      - 'v[0-9]+.[0-9]+.[0-9]*'
    branches:
      - build-*
  schedule:
    - cron: "05 00 * * *"
  workflow_dispatch:
    inputs:
      customTag:
        description: "Development Tag"
        required: true
        default: "development-tag"

env:
  TBN_FILENAME: "tari_suite"
  TBN_BUNDLE_ID_BASE: "com.tarilabs.pkg"
  toolchain: nightly-2024-02-01
  matrix-json-file: ".github/workflows/base_node_binaries.json"
  CARGO_HTTP_MULTIPLEXING: false
  CARGO_UNSTABLE_SPARSE_REGISTRY: true
  CARGO: cargo
  # CARGO_OPTIONS: "--verbose"
  CARGO_OPTIONS: "--release"

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  matrix-prep:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: false

      - name: Set Matrix
        id: set-matrix
        run: |
          #
          # build all targets images
          # matrix=$( jq -s -c .[] .github/workflows/base_node_binaries.json )
          #
          # build only single target image
          # matrix_selection=$( jq -c '.[] | select( ."name" == "windows-x64" )' ${{ env.matrix-json-file }} )
          # matrix_selection=$( jq -c '.[] | select( ."name" == "macos-arm64" )' ${{ env.matrix-json-file }} )
          #
          # build select target images - build_enabled
          matrix_selection=$( jq -c '.[] | select( ."build_enabled" != false )' ${{ env.matrix-json-file }} )
          #
          # Setup the json build matrix
          matrix=$(echo ${matrix_selection} | jq -s -c '{"builds": .}')
          echo $matrix
          echo $matrix | jq .
          echo "matrix=${matrix}" >> $GITHUB_OUTPUT

  matrix-check:
    # Debug matrix
    if: ${{ false }}
    runs-on: ubuntu-latest
    needs: matrix-prep
    steps:
      - name: Install json2yaml
        run: |
          sudo npm install -g json2yaml

      - name: Check matrix definition
        run: |
          matrix='${{ needs.matrix-prep.outputs.matrix }}'
          echo $matrix
          echo $matrix | jq .
          echo $matrix | json2yaml

  builds:
    name: Building ${{ matrix.builds.name }} on ${{ matrix.builds.runs-on }}
    needs: matrix-prep
    outputs:
      TARI_NETWORK_DIR: ${{ steps.set-tari-network.outputs.TARI_NETWORK_DIR }}
      TARI_VERSION: ${{ steps.set-tari-vars.outputs.TARI_VERSION }}
    strategy:
      fail-fast: false
      matrix: ${{ fromJson(needs.matrix-prep.outputs.matrix) }}
    runs-on: ${{ matrix.builds.runs-on }}

    steps:
      - name: Checkout source code
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Declare TestNet for tags
        id: set-tari-network
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        shell: bash
        run: |
          source buildtools/multinet_envs.sh ${{ github.ref_name }}
          echo ${TARI_NETWORK}
          echo ${TARI_NETWORK_DIR}
          echo "TARI_NETWORK=${TARI_NETWORK}" >> $GITHUB_ENV
          echo "TARI_NETWORK_DIR=${TARI_NETWORK_DIR}" >> $GITHUB_ENV
          echo "TARI_NETWORK_DIR=${TARI_NETWORK_DIR}" >> $GITHUB_OUTPUT

      - name: Declare Global Variables 4 GHA ${{ github.event_name }}
        id: set-tari-vars
        shell: bash
        run: |
          echo "VBRANCH=${{ github.ref_name }}" >> $GITHUB_ENV
          echo "VSHA_SHORT=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
          TARI_VERSION=$(awk -F ' = ' '$1 ~ /version/ { gsub(/["]/, "", $2); printf("%s",$2) }' "$GITHUB_WORKSPACE/applications/minotari_node/Cargo.toml")
          echo "TARI_VERSION=${TARI_VERSION}" >> $GITHUB_ENV
          echo "TARI_VERSION=${TARI_VERSION}" >> $GITHUB_OUTPUT

      - name: Scheduled Destination Folder Override
        if: ${{ github.event_name == 'schedule' && github.event.schedule == '05 00 * * *' }}
        shell: bash
        run: |
          echo "S3_DEST_OVERRIDE=daily/" >> $GITHUB_ENV

      - name: Setup Rust toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          components: rustfmt, clippy
          toolchain: ${{ matrix.builds.rust }}
          targets: ${{ matrix.builds.target }}

      - name: Install Linux dependencies - Ubuntu
        if: ${{ startsWith(runner.os,'Linux') && ( ! matrix.builds.cross ) }}
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies.sh

      - name: Install Linux dependencies - Ubuntu - cross-compile arm64 on x86-64
        if: ${{ startsWith(runner.os,'Linux') && ( ! matrix.builds.cross ) && matrix.builds.name == 'linux-arm64' }}
        run: |
          sudo apt-get update
          sudo bash scripts/install_ubuntu_dependencies-arm64.sh
          rustup target add ${{ matrix.builds.target }}

      - name: Install macOS dependencies
        if: startsWith(runner.os,'macOS')
        run: |
          brew install openssl cmake coreutils automake autoconf protobuf
          rustup target add ${{ matrix.builds.target }}

      - name: Install Windows dependencies
        if: startsWith(runner.os,'Windows')
        run: |
          vcpkg.exe install sqlite3:x64-windows zlib:x64-windows
          # Bug in choco - need to install each package individually
          choco upgrade llvm -y
          # psutils is out of date
          # choco upgrade psutils -y
          choco upgrade openssl -y
          # Should already be installed
          # choco upgrade strawberryperl -y
          choco upgrade protoc -y

      - name: Set environment variables - Nix
        if: ${{ ! startsWith(runner.os,'Windows') }}
        shell: bash
        run: |
          echo "SHARUN=shasum --algorithm 256" >> $GITHUB_ENV
          echo "CC=gcc" >> $GITHUB_ENV
          echo "TBN_EXT=" >> $GITHUB_ENV
          echo "SHELL_EXT=.sh" >> $GITHUB_ENV
          echo "PLATFORM_SPECIFIC_DIR=linux" >> $GITHUB_ENV
          echo "TBN_DIST=/dist" >> $GITHUB_ENV

      - name: Set environment variables - macOS
        if: startsWith(runner.os,'macOS')
        shell: bash
        run: |
          echo "PLATFORM_SPECIFIC_DIR=osx" >> $GITHUB_ENV
          echo "LIB_EXT=.dylib" >> $GITHUB_ENV

      - name: Set environment variables - Ubuntu
        if: startsWith(runner.os,'Linux')
        shell: bash
        run: |
          echo "LIB_EXT=.so" >> $GITHUB_ENV

      - name: Set environment variables - Windows
        if: startsWith(runner.os,'Windows')
        shell: bash
        run: |
          # echo "SHARUN=pwsh C:\ProgramData\chocolatey\lib\psutils\tools\psutils-master\shasum.ps1 --algorithm 256" >> $GITHUB_ENV
          mkdir -p "$GITHUB_WORKSPACE\psutils"
          curl -v -o "$GITHUB_WORKSPACE\psutils\getopt.ps1" "https://raw.githubusercontent.com/lukesampson/psutils/master/getopt.ps1"
          curl -v -o "$GITHUB_WORKSPACE\psutils\shasum.ps1" "https://raw.githubusercontent.com/lukesampson/psutils/master/shasum.ps1"
          echo "SHARUN=pwsh $GITHUB_WORKSPACE\psutils\shasum.ps1 --algorithm 256" >> $GITHUB_ENV
          echo "TBN_EXT=.exe" >> $GITHUB_ENV
          echo "LIB_EXT=.dll" >> $GITHUB_ENV
          echo "SHELL_EXT=.bat" >> $GITHUB_ENV
          echo "TBN_DIST=\dist" >> $GITHUB_ENV
          echo "PLATFORM_SPECIFIC_DIR=windows" >> $GITHUB_ENV
          echo "SQLITE3_LIB_DIR=C:\vcpkg\installed\x64-windows\lib" >> $GITHUB_ENV
          echo "OPENSSL_DIR=C:\Program Files\OpenSSL-Win64" >> $GITHUB_ENV
          echo "LIBCLANG_PATH=C:\Program Files\LLVM\bin" >> $GITHUB_ENV
          echo "C:\Strawberry\perl\bin" >> $GITHUB_PATH

      - name: Cache cargo files and outputs
        if: ${{ ( ! startsWith(github.ref, 'refs/tags/v') ) && ( ! matrix.builds.cross ) }}
        uses: Swatinem/rust-cache@v2
        with:
          key: ${{ matrix.builds.target }}

      - name: Install and setup cargo cross
        if: ${{ matrix.builds.cross }}
        shell: bash
        run: |
          cargo install cross
          echo "CARGO=cross" >> $GITHUB_ENV

      - name: Install and setup cargo-auditable
        if: ${{ false }}
        # if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        shell: bash
        run: |
          cargo install cargo-auditable
          echo "CARGO=${{ env.CARGO }} auditable" >> $GITHUB_ENV
          echo "CARGO_OPTIONS=${{ env.CARGO_OPTIONS }} --release" >> $GITHUB_ENV

      - name: Show command used for Cargo
        shell: bash
        run: |
          echo "cargo command is: ${{ env.CARGO }}"
          echo "cargo options is: ${{ env.CARGO_OPTIONS }}"
          echo "cross flag: ${{ matrix.builds.cross }}"

      - name: Build release binaries
        shell: bash
        run: |
          ${{ env.CARGO }} build ${{ env.CARGO_OPTIONS }} \
            --target ${{ matrix.builds.target }} \
            --features "${{ matrix.builds.features }}" \
            ${{ matrix.builds.target_bins }} \
            ${{ matrix.builds.flags }} --locked

      - name: Copy binaries to folder for archiving
        shell: bash
        run: |
          mkdir -p "$GITHUB_WORKSPACE${TBN_DIST}"
          cd "$GITHUB_WORKSPACE${TBN_DIST}"
          BINFILE="${TBN_FILENAME}-${TARI_VERSION}-${VSHA_SHORT}-${{ matrix.builds.name }}${TBN_EXT}"
          echo "BINFILE=${BINFILE}" >> $GITHUB_ENV
          echo "Copying files for ${BINFILE} to $(pwd)"
          echo "MTS_SOURCE=$(pwd)" >> $GITHUB_ENV
          ls -la "$GITHUB_WORKSPACE/target/${{ matrix.builds.target }}/release/"
          FILES=(
            "minotari_node"
            "minotari_console_wallet"
            "minotari_miner"
            "minotari_merge_mining_proxy"
          )
          for FILE in "${FILES[@]}"; do
            if [ -f "$GITHUB_WORKSPACE/target/${{ matrix.builds.target }}/release/${FILE}${TBN_EXT}" ]; then
              cp -v "$GITHUB_WORKSPACE/target/${{ matrix.builds.target }}/release/${FILE}${TBN_EXT}" .
            fi
          done
          if [ -f "$GITHUB_WORKSPACE/applications/minotari_node/${PLATFORM_SPECIFIC_DIR}/runtime/start_tor${SHELL_EXT}" ]; then
            cp -v "$GITHUB_WORKSPACE/applications/minotari_node/${PLATFORM_SPECIFIC_DIR}/runtime/start_tor${SHELL_EXT}" .
          fi
          ls -la ${{ env.MTS_SOURCE }}

      - name: Build the macOS pkg
        if: startsWith(runner.os,'macOS')
        continue-on-error: true
        env:
          MACOS_KEYCHAIN_PASS: ${{ secrets.MACOS_KEYCHAIN_PASS }}
          MACOS_APPLICATION_ID: ${{ secrets.MACOS_APPLICATION_ID }}
          MACOS_APPLICATION_CERT: ${{ secrets.MACOS_APPLICATION_CERT }}
          MACOS_APPLICATION_PASS: ${{ secrets.MACOS_APPLICATION_PASS }}
          MACOS_INSTALLER_ID: ${{ secrets.MACOS_INSTALLER_ID }}
          MACOS_INSTALLER_CERT: ${{ secrets.MACOS_INSTALLER_CERT }}
          MACOS_INSTALLER_PASS: ${{ secrets.MACOS_INSTALLER_PASS }}
          MACOS_NOTARIZE_USERNAME: ${{ secrets.MACOS_NOTARIZE_USERNAME }}
          MACOS_NOTARIZE_PASSWORD: ${{ secrets.MACOS_NOTARIZE_PASSWORD }}
          MACOS_ASC_PROVIDER: ${{ secrets.MACOS_ASC_PROVIDER }}
        run: |
          echo $MACOS_APPLICATION_CERT | base64 --decode > application.p12
          echo $MACOS_INSTALLER_CERT | base64 --decode > installer.p12
          security create-keychain -p $MACOS_KEYCHAIN_PASS build.keychain
          security default-keychain -s build.keychain
          security unlock-keychain -p $MACOS_KEYCHAIN_PASS build.keychain
          security import application.p12 -k build.keychain -P $MACOS_APPLICATION_PASS -T /usr/bin/codesign
          security import installer.p12 -k build.keychain -P $MACOS_INSTALLER_PASS -T /usr/bin/pkgbuild
          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $MACOS_KEYCHAIN_PASS build.keychain
          cd buildtools
          export target_release="target/${{ matrix.builds.target }}/release"
          ./create_osx_install_zip.sh unused nozip
          FILES=(
            "minotari_node"
            "minotari_console_wallet"
            "minotari_miner"
            "minotari_merge_mining_proxy"
          )
          for FILE in "${FILES[@]}"; do
            codesign --options runtime --force --verify --verbose --timestamp --sign "Developer ID Application: $MACOS_APPLICATION_ID" "/tmp/tari_testnet/runtime/$FILE"
            codesign --verify --deep --display --verbose=4 "/tmp/tari_testnet/runtime/$FILE"
            cp -vf "/tmp/tari_testnet/runtime/$FILE" "$GITHUB_WORKSPACE${{ env.TBN_DIST }}"
          done
          distDirPKG=$(mktemp -d -t ${{ env.TBN_FILENAME }})
          echo "${distDirPKG}"
          echo "distDirPKG=${distDirPKG}" >> $GITHUB_ENV
          TBN_Temp=${{ env.TBN_FILENAME }}
          TBN_BUNDLE_ID_VALID_NAME=$(echo "${TBN_Temp//_/-}")
          # Strip apple-darwin
          TBN_ARCH=$(echo "${${{ matrix.builds.target }}//-apple-darwin/}")
          pkgbuild --root /tmp/tari_testnet \
            --identifier "${{ env.TBN_BUNDLE_ID_BASE }}.${TBN_BUNDLE_ID_VALID_NAME}" \
            --version "${TARI_VERSION}" \
            --install-location "/tmp/tari" \
            --scripts "/tmp/tari_testnet/scripts" \
            --sign "Developer ID Installer: ${MACOS_INSTALLER_ID}" \
            "${distDirPKG}/${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg"
          echo -e "Submitting to Apple...\n\n"
          xcrun altool --notarize-app \
            --primary-bundle-id "${{ env.TBN_BUNDLE_ID_BASE }}.${TBN_BUNDLE_ID_VALID_NAME}" \
            --username "${MACOS_NOTARIZE_USERNAME}" --password "${MACOS_NOTARIZE_PASSWORD}" \
            --asc-provider "${MACOS_ASC_PROVIDER}" \
            --file "${distDirPKG}/${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg" &> notarisation.result
          requestUUID=`grep RequestUUID notarisation.result | cut -d" " -f 3`
          echo ${requestUUID}
          if [[ ${requestUUID} == "" ]]; then
            echo "could not upload for notarization"
            exit 1
          else
            echo "Notarization RequestUUID: ${requestUUID}"
          fi
          echo -e "\n\nChecking result of notarisation..."
          request_status="in progress"
          while [[ "${request_status}" == "in progress" ]]; do
            echo -n "waiting... "
            sleep 10
            request_status=$(xcrun altool --notarization-info ${requestUUID} --username "${MACOS_NOTARIZE_USERNAME}" --password "${MACOS_NOTARIZE_PASSWORD}" 2>&1)
            echo "${request_status}"
            request_status=$(echo "${request_status}" | awk -F ': ' '/Status:/ { print $2; }' )
            echo "${request_status}"
          done
          echo "${request_status}"
          if [[ ${request_status} != "success" ]]; then
            echo "## could not notarize - ${request_status} - ${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg"
            exit 1
          else
            echo -e "\nStapling package...${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg\n"
            xcrun stapler staple -v "${distDirPKG}/${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg"
          fi
          cd ${distDirPKG}
          ls -la
          echo "Compute pkg shasum"
          ${SHARUN} "${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg" \
            >> "${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg.sha256"
          cat "${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg.sha256"
          echo "Checksum verification for pkg is "
          ${SHARUN} --check "${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg.sha256"
          cp -v *.pkg* ${{ env.MTS_SOURCE }}

      - name: Artifact upload for macOS pkg
        if: startsWith(runner.os,'macOS')
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}.pkg
          path: "${{ env.distDirPKG }}/${{ env.TBN_FILENAME }}-${{ matrix.builds.name }}-${{ env.TARI_VERSION }}*.pkg*"

      - name: Build the Windows installer
        shell: cmd
        if: startsWith(runner.os,'Windows')
        run: |
          cd buildtools
          "%programfiles(x86)%\Inno Setup 6\iscc.exe" "/DMyAppVersion=${{ env.TARI_VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.builds.name }}-installer" "/DMinotariSuite=${{ env.TBN_FILENAME }}" "/DTariSuitePath=${{ github.workspace }}${{ env.TBN_DIST }}" "windows_inno_installer.iss"
          cd Output
          echo "Compute archive shasum"
          ${{ env.SHARUN }} "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.builds.name }}-installer.exe" >> "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.builds.name }}-installer.exe.sha256"
          echo "Show the shasum"
          cat "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.builds.name }}-installer.exe.sha256"
          echo "Checksum verification archive is "
          ${{ env.SHARUN }} --check "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}-${{ env.VSHA_SHORT }}-${{ matrix.builds.name }}-installer.exe.sha256"

      - name: Artifact upload for Windows installer
        uses: actions/upload-artifact@v4
        if: startsWith(runner.os,'Windows')
        with:
          name: "${{ env.TBN_FILENAME }}_windows_installer"
          path: "${{ github.workspace }}/buildtools/Output/*"

      - name: Archive and Checksum Binaries
        shell: bash
        run: |
          echo "Archive ${{ env.BINFILE }} too ${{ env.BINFILE }}.zip"
          cd "$GITHUB_WORKSPACE${{ env.TBN_DIST }}"
          echo "Compute files shasum"
          ${SHARUN} * >> "${{ env.BINFILE }}.sha256"
          echo "Show the shasum"
          cat "${{ env.BINFILE }}.sha256"
          echo "Checksum verification for files is "
          ${SHARUN} --check "${{ env.BINFILE }}.sha256"
          7z a "${{ env.BINFILE }}.zip" *
          echo "Compute archive shasum"
          ${SHARUN} "${{ env.BINFILE }}.zip" >> "${{ env.BINFILE }}.zip.sha256"
          echo "Show the shasum"
          cat "${{ env.BINFILE }}.zip.sha256"
          echo "Checksum verification archive is "
          ${SHARUN} --check "${{ env.BINFILE }}.zip.sha256"

      - name: Artifact upload for Archive
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.TBN_FILENAME }}_archive-${{ matrix.builds.name }}
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/${{ env.BINFILE }}.zip*"

      - name: Prep Miner for upload
        shell: bash
        run: |
          cd "${{ github.workspace }}${{ env.TBN_DIST }}"
          cp -v "minotari_miner${{ env.TBN_EXT}}" \
            "minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}"
          echo "Compute miner shasum"
          ${SHARUN} "minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}" \
            >> "minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}.sha256"
          echo "Show the shasum"
          cat "minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}.sha256"
          echo "Checksum verification for miner is "
          ${SHARUN} --check "minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}.sha256"

      - name: Artifact upload for Miner
        uses: actions/upload-artifact@v4
        with:
          name: minotari_miner-${{ matrix.builds.name }}
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/minotari_miner-${{ matrix.builds.name }}${{ env.TBN_EXT}}*"

      - name: Prep diag-utils archive for upload
        continue-on-error: true
        shell: bash
        run: |
          mkdir "${{ github.workspace }}${{ env.TBN_DIST }}/diag-utils"
          cd "${{ github.workspace }}${{ env.TBN_DIST }}/diag-utils"
          # Find RandomX built tools for testing
          find "$GITHUB_WORKSPACE/target/${{ matrix.builds.target }}/release/" \
            -name "randomx-*${{ env.TBN_EXT}}" -type f -perm -+x -exec cp -v {} . \;
          echo "Compute diag utils shasum"
          ${SHARUN} * \
            >> "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.sha256"
          cat "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.sha256"
          echo "Checksum verification for diag utils is "
          ${SHARUN} --check "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.sha256"
          7z a "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.zip" *
          echo "Compute diag utils archive shasum"
          ${SHARUN} "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.zip" \
            >> "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.zip.sha256"
          cat "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.zip.sha256"
          echo "Checksum verification for diag utils archive is "
          ${SHARUN} --check "${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}.zip.sha256"

      - name: Artifact upload for diag-utils
        continue-on-error: true
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.TBN_FILENAME }}_archive-diag-utils-${{ matrix.builds.name }}
          path: "${{ github.workspace }}${{ env.TBN_DIST }}/diag-utils/*.zip*"

  create-release:
    if: ${{ startsWith(github.ref, 'refs/tags/v') }}
    runs-on: ubuntu-latest
    needs: builds
    env:
      TARI_NETWORK_DIR: ${{ needs.builds.outputs.TARI_NETWORK_DIR }}
      TARI_VERSION: ${{ needs.builds.outputs.TARI_VERSION }}

    steps:
      - name: Download binaries
        uses: actions/download-artifact@v4
        with:
          path: ${{ env.TBN_FILENAME }}
          pattern: "${{ env.TBN_FILENAME }}*"
          merge-multiple: true

      - name: Verify checksums and Prep Uploads
        shell: bash
        working-directory: ${{ env.TBN_FILENAME }}
        run: |
          # set -xo pipefail
          sudo apt-get update
          sudo apt-get --no-install-recommends --assume-yes install dos2unix
          ls -alhtR
          if [ -f "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned" ] ; then
            rm -fv "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned"
          fi
          # Merge all sha256 files into one
          find . -name "*.sha256" -type f -print | xargs cat >> "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned"
          dos2unix --quiet "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned"
          cat "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned"
          sha256sum --ignore-missing --check "${{ env.TBN_FILENAME }}-${{ env.TARI_VERSION }}.txt.sha256-unsigned"
          ls -alhtR

      - name: Create release
        uses: ncipollo/release-action@v1
        with:
          artifacts: "${{ env.TBN_FILENAME }}*/**/*"
          token: ${{ secrets.GITHUB_TOKEN }}
          prerelease: true
          draft: true
          allowUpdates: true
          updateOnlyUnreleased: true
          replacesArtifacts: true

      - name: Sync assets to S3
        continue-on-error: true # Don't break if s3 upload fails
        if: ${{ env.AWS_SECRET_ACCESS_KEY != '' && matrix.builds.runs-on != 'self-hosted' }}
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          S3CMD: "cp"
          S3OPTIONS: '--recursive --exclude "*" --include "*.sha256*" --include "*.zip*" --include "*.pkg*" --include "*installer.exe*"'
        shell: bash
        working-directory: ${{ env.TBN_FILENAME }}
        run: |
          echo "Upload processing ..."
          ls -alhtR
          echo "Clean up"
          # Bash check if file with wildcards, does not work as expected
          # if [ -f ${{ env.TBN_FILENAME }}*diag-utils* ] ; then
          if ls ${{ env.TBN_FILENAME }}*diag-utils* > /dev/null 2>&1 ; then
            rm -fv ${{ env.TBN_FILENAME }}*diag-utils*
          fi
          echo "Folder setup"
          if ls ${{ env.TBN_FILENAME }}*linux* > /dev/null 2>&1 ; then
            mkdir -p "linux/${{ env.TARI_NETWORK_DIR }}/"
            mv -v ${{ env.TBN_FILENAME }}*linux* "linux/${{ env.TARI_NETWORK_DIR }}/"
          fi
          if ls ${{ env.TBN_FILENAME }}*macos* > /dev/null 2>&1 ; then
            mkdir -p "osx/${{ env.TARI_NETWORK_DIR }}/"
            mv -v ${{ env.TBN_FILENAME }}*macos* "osx/${{ env.TARI_NETWORK_DIR }}/"
          fi
          if ls ${{ env.TBN_FILENAME }}*windows* > /dev/null 2>&1 ; then
            mkdir -p "windows/${{ env.TARI_NETWORK_DIR }}/"
            mv -v ${{ env.TBN_FILENAME }}*windows* "windows/${{ env.TARI_NETWORK_DIR }}/"
          fi
          ls -alhtR
          aws --version
          echo "ls current"
          aws s3 ls --region ${{ secrets.AWS_REGION }} \
            s3://${{ secrets.AWS_S3_BUCKET }}/current/
          echo "Upload current"
          aws s3 ${{ env.S3CMD }} --region ${{ secrets.AWS_REGION }} \
            . \
            s3://${{ secrets.AWS_S3_BUCKET }}/current/ \
            ${{ env.S3OPTIONS }}