release.yml

name: Release (with lint and test)

on:
  push:
    tags:
      - "*"

permissions:
  contents: read

env:
  FOUNDRY_PROFILE: ci
  L1_FORK_URL: ${{ secrets.L1_FORK_URL }}
  L2_FORK_URL: ${{ secrets.L2_FORK_URL }}

jobs:
  lint:
    name: lint
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repo
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Set up Go
        uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5.5.0
        with:
          go-version: '1.24.2'

      - name: Install dependencies
        run: |
          go mod tidy

      - name: Run golangci-lint
        uses: golangci/golangci-lint-action@55c2c1448f86e01eaae002a5a3a9624417608d84 # v6.5.2
        with:
          version: latest
          args: --timeout 3m
  test:
    name: test
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repo
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Set up Go
        uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5.5.0
        with:
          go-version: '1.24.2'

      - name: run tests
        run: |
          go mod tidy
          make tests
  
  build-create-release:
    runs-on: ubuntu-latest
    needs: [lint, test]
    permissions:
      contents: write
      actions: read
    steps:
      - name: Checkout
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Check and set release version
        env:
          REF: ${{ github.ref }}
        run: |
          ./scripts/version.sh $REF

      - name: Build binary
        env:
          RELEASE_BUCKET_NAME: ${{ secrets.RELEASE_BUCKET_NAME }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_REGION: ${{ secrets.AWS_REGION }}
          TELEMETRY_TOKEN: ${{ secrets.TELEMETRY_TOKEN }}
        run: |
          go mod tidy
          
          VERSION=$(cat VERSION | tr -d '[:space:]')
          echo "Building binary for version $VERSION"
          make release
          sudo chown -R $USER:$USER .
          ./scripts/bundleReleases.sh $VERSION
          
          # Create the content using a heredoc assigned to a variable
          RELEASE_BODY=$(cat << 'EOF'
          ## Downloads
          EOF
          )
          
          # Create a temporary file to build up the release body
          echo "$RELEASE_BODY" > release_body_temp.txt
          
          for asset_name in $(ls ./release | grep '.tar');
          do
          asset="./release/${asset_name}"
          echo "Uploading ${asset_name}..."
          aws s3 cp "$asset" "s3://${RELEASE_BUCKET_NAME}/$VERSION/"
          
          # append to the release body file with proper newlines
          echo "- [${asset_name}](https://s3.amazonaws.com/${RELEASE_BUCKET_NAME}/$VERSION/${asset_name})" >> release_body_temp.txt
          done
          
          # Read the complete release body from the file
          RELEASE_BODY=$(cat release_body_temp.txt)
          
          # Set it as an environment variable for later steps
          echo 'RELEASE_BODY<<EOF' >> $GITHUB_ENV
          echo "$RELEASE_BODY" >> $GITHUB_ENV
          echo 'EOF' >> $GITHUB_ENV

      - name: Create Release
        id: create_release
        uses: actions/create-release@0cb9c9b65d5d1901c1f53e5e66eaf4afd303e70e # v1.1.4
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: false
          prerelease: false
          body: ${{ env.RELEASE_BODY }}

      - name: Upload Release Asset
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          RELEASE_BUCKET_NAME: ${{ vars.RELEASE_BUCKET_NAME }}
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_REGION: ${{ secrets.AWS_REGION }}
        run: |
          set -x
          ls -al ./release
      
          echo "Upload URL: ${{ steps.create_release.outputs.upload_url }}"
          export upload_url=$(echo "${{ steps.create_release.outputs.upload_url }}" | sed -e "s/{?name,label}//")
      
          for asset_name in $(ls ./release | grep '.tar');
          do
            asset="./release/${asset_name}"
            echo "Uploading ${asset_name}..."
            curl --fail \
              -H "Authorization: token $GITHUB_TOKEN" \
              -H "Content-Type: $(file -b --mime-type "$asset")" \
              --data-binary @"$asset" \
              "${upload_url}?name=$asset_name"
          done

  smoke-test-binaries:
    needs: build-create-release 
    strategy:
      matrix:
        os: [macos-latest, ubuntu-latest]
        arch: [x64, arm64]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout repo @ tag
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

      - name: Read version
        id: ver
        run: |
          echo "VERSION=$(<VERSION)" >> $GITHUB_ENV

      - name: Setup QEMU (for arm64 on Linux runner)
        if: matrix.os == 'ubuntu-latest' && matrix.arch == 'arm64'
        uses: docker/setup-qemu-action@29109295f81e9208d7d86ff1c6c12d2833863392 # v3.6.0
        with:
          platforms: linux/arm64

      - name: Install devkit
        run: |
          set -euxo pipefail
          ver="${{ env.VERSION }}"
          case "${{ matrix.os }}-${{ matrix.arch }}" in
            "macos-latest-x64")   url="https://s3.amazonaws.com/eigenlayer-devkit-releases/${ver}/devkit-darwin-amd64-${ver}.tar.gz" ;;
            "macos-latest-arm64") url="https://s3.amazonaws.com/eigenlayer-devkit-releases/${ver}/devkit-darwin-arm64-${ver}.tar.gz" ;;
            "ubuntu-latest-x64")  url="https://s3.amazonaws.com/eigenlayer-devkit-releases/${ver}/devkit-linux-amd64-${ver}.tar.gz" ;;
            "ubuntu-latest-arm64")url="https://s3.amazonaws.com/eigenlayer-devkit-releases/${ver}/devkit-linux-arm64-${ver}.tar.gz" ;;
            *) echo "Unsupported combination"; exit 1 ;;
          esac
          mkdir -p "$HOME/bin"
          echo "::set-output name=url::$url"
          curl -fsSL "$url" | tar -x -C "$HOME/bin" -f -

      - name: Verify installation
        run: |
          export PATH="$HOME/bin:$PATH"
          # expected version from file
          ver="${{ env.VERSION }}"
          # extract the `devkit version` Version line
          installed=$(devkit version \
            | awk '/^Version:/ { print $2 }')
          if [[ "$installed" != "$ver" ]]; then
            echo "✖ version mismatch: expected $ver, got $installed"
            exit 1
          fi
          echo "✔ version $installed matches expected $ver"

      - name: Add ~/bin to PATH
        run: echo "$HOME/bin" >> $GITHUB_PATH

      - name: Install Homebrew (macOS -x64)
        if: matrix.os == 'macos-latest' && matrix.arch == 'x64'
        run: |
          # enable Rosetta (needed only on Apple Silicon hosts)
          sudo softwareupdate --install-rosetta --agree-to-license || true

          # install Intel Homebrew into /usr/local
          arch -x86_64 /bin/bash -c \
            "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

          # capture the brew-env exports into GITHUB_ENV
          arch -x86_64 /usr/local/bin/brew shellenv \
            | sed 's/^export //g' >> $GITHUB_ENV

          # alias brew via a shim
          mkdir -p $HOME/bin
          printf '%s\n' '#!/usr/bin/env bash' \
            'exec arch -x86_64 /usr/local/bin/brew "$@"' \
            > "$HOME/bin/brew"
          chmod +x "$HOME/bin/brew"

          # make sure our shim comes first
          echo "$HOME/bin" >> $GITHUB_PATH

          # verify brew is on PATH and running under x86_64
          which brew
          file "$(which brew)"
          brew --version

      - name: Set up Go
        uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5.5.0
        with:
          go-version: "1.24"

      - name: Install Foundry
        uses: foundry-rs/foundry-toolchain@82dee4ba654bd2146511f85f0d013af94670c4de # v1.4.0
        with:
          version: stable

      - name: Install Colima, Lima guestagents & Docker CLI (macOS)
        if: matrix.os == 'macos-latest'
        run: |
          # use the ARM-native Homebrew for host tools
          BREW_ARM=/opt/homebrew/bin/brew

          echo "Using ARM Homebrew at $BREW_ARM"

          # install Lima, Colima and Docker CLI natively
          $BREW_ARM install lima colima docker
          $BREW_ARM install lima-additional-guestagents

          # ensure ARM brews bin is on PATH for all later steps
          echo "/opt/homebrew/bin" >> $GITHUB_PATH
          echo "$HOME/bin" >> $GITHUB_PATH

          # sanity-check
          which colima
          file "$(which colima)"
          colima version
          which docker
          docker --version

      - name: Install Docker Compose plugin (macOS)
        if: matrix.os == 'macos-latest'
        env:
          GHA_ARCH: ${{ matrix.arch }}
        run: |
          # create plugin dir
          mkdir -p ~/.docker/cli-plugins

          # select binary according to arch
          case "$GHA_ARCH" in
            arm64) FILE=docker-compose-darwin-aarch64 ;;
            x64)   FILE=docker-compose-darwin-x86_64 ;;
            *)
              echo "Unsupported arch: $GHA_ARCH"
              exit 1
              ;;
          esac

          # download the Compose V2 binary
          curl -SL \
            "https://github.com/docker/compose/releases/download/v2.36.2/${FILE}" \
            -o ~/.docker/cli-plugins/docker-compose
          chmod +x ~/.docker/cli-plugins/docker-compose

          # verify
          docker compose version

      - name: Install Docker Buildx (macOS)
        if: matrix.os == 'macos-latest'
        run:  |
          brew install docker-buildx

          # ensure the CLI-plugins dir exists
          mkdir -p ~/.docker/cli-plugins

          # symlink the Homebrew buildx into Dockers plugin folder
          ln -sf "$(brew --prefix)/bin/docker-buildx" ~/.docker/cli-plugins/docker-buildx

          # install it as the default builder
          docker buildx install

          # verify
          docker buildx version

      - name: Start Colima under QEMU (macOS)
        if: matrix.os == 'macos-latest'
        run: |
          # boot the VM + Docker
          colima start \
            --vm-type qemu \
            --runtime docker \
            --arch x86_64 \
            --cpu 4 \
            --memory 8 \
            --disk 50 \
            --activate

      - name: Switch Docker context (macOS)
        if: matrix.os == 'macos-latest'
        run: docker context use colima

      - name: Link Docker socket for Docker CLI (macOS)
        if: matrix.os == 'macos-latest'
        run: sudo ln -sf $HOME/.colima/default/docker.sock /var/run/docker.sock

      - name: Verify Docker daemon (macOS)
        if: matrix.os == 'macos-latest'
        run: |
          for i in {1..30}; do
            docker info &>/dev/null && break
            echo "Waiting for Colima Docker context... ($i/30)"
            sleep 2
          done
          docker info

      - name: Run devkit avs create
        run: devkit avs create --disable-telemetry my-awesome-avs

      - name: Verify AVS project created
        run: |
          if [ ! -f "./my-awesome-avs/config/config.yaml" ]; then
            echo "❌ AVS project config/config.yaml not found!"
            exit 1
          fi
          echo "✅ AVS project created successfully at ${GITHUB_WORKSPACE}/my-awesome-avs/"

      - name: Link gomplate (macOS)
        if: matrix.os == 'macos-latest'
        run: |
          mkdir -p "${GOPATH:-$HOME/go}/bin"
          ln -sf "$(brew --prefix)/bin/gomplate" "${GOPATH:-$HOME/go}/bin/gomplate"

      - name: Run devkit avs build
        env:
          DOCKER_BUILDKIT: 1
        run: |
          cd ./my-awesome-avs/
          devkit avs build

      - name: Start devnet
        run: |
          cd ./my-awesome-avs/
          devkit avs devnet start &
          until nc -z localhost 9090 && nc -z localhost 8081; do sleep 1; done

      - name: Check devnet RPC is live
        run: |
          for i in {1..10}; do
            bn=$(cast block-number --rpc-url http://localhost:8545 || echo "error")
            if [ "$bn" != "error" ]; then
              echo "Current block number: $bn"
              exit 0
            fi
            echo "Waiting for devnet... retrying in 2s"
            sleep 2
          done
          echo "❌ Devnet failed to start"
          exit 1

      - name: Call AVS
        run: |
          cd ./my-awesome-avs/
          devkit avs call -- signature="(uint256,string)" args='(5,"hello")'

      - name: Stop devnet
        run: |
          cd ./my-awesome-avs/
          devkit avs devnet stop