ere/.github/workflows/test-zkvm.yml

name: Test and clippy zkVM

on:
  workflow_call:
    inputs:
      zkvm:
        description: 'zkVM to test'
        required: true
        type: string
      toolchain:
        description: 'Rust toolchain to use'
        required: false
        type: string
        default: 1.86.0
      test_ere_dockerized:
        description: 'Whether test ere-dockerized with the selected zkVM or not'
        required: false
        type: boolean
        default: true
      # Currently only needed by those zkvms that need Cuda during building process by default
      default_features:
        description: 'Cargo clippy/build with default features or not'
        required: false
        type: boolean
        default: true
      # Remove when we use larger runners, currently only needed to skip some zisk test
      test_options:
        description: 'Cargo test options when testing via Docker'
        required: false
        type: string
        default: ''

env:
  CARGO_TERM_COLOR: always

jobs:
  build_image:
    name: Build image
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    outputs:
      image_version: ${{ steps.image_tag.outputs.image_version }}
      base_image_tag: ${{ steps.image_tag.outputs.base_image_tag }}
      base_zkvm_image_tag: ${{ steps.image_tag.outputs.base_zkvm_image_tag }}
      cli_zkvm_image_tag: ${{ steps.image_tag.outputs.cli_zkvm_image_tag }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Check Dockerfile changes
        id: changed_files
        uses: tj-actions/changed-files@v46
        with:
          files: |
            docker/base/Dockerfile.base
            docker/${{ inputs.zkvm }}/Dockerfile
            scripts/sdk_installers/install_${{ inputs.zkvm }}_sdk.sh

      - name: Get image version and tags of ere-base and ere-base-${{ inputs.zkvm }}
        id: image_tag
        run: |
          ZKVM_CRATE_VERSION=$(cargo metadata --format-version=1 --no-deps | jq -r '.packages[] | select(.name == "ere-${{ inputs.zkvm }}") | .version')

          GIT_REV="${{ github.sha }}"
          if [ "${{ github.event_name }}" == "pull_request" ] && [ "${{ steps.changed_files.outputs.any_changed }}" == "false" ]; then
            CACHED_GIT_REV="${{ github.event.pull_request.base.sha }}"
          else
            CACHED_GIT_REV="$GIT_REV"
          fi

          IMAGE_VERSION="$ZKVM_CRATE_VERSION-${GIT_REV:0:7}"
          CACHED_IMAGE_VERSION="$ZKVM_CRATE_VERSION-${CACHED_GIT_REV:0:7}"

          IMAGE_REPO="ghcr.io/${{ github.repository }}"
          BASE_IMAGE_TAG="$IMAGE_REPO/ere-base:$CACHED_IMAGE_VERSION"
          BASE_ZKVM_IMAGE_TAG="$IMAGE_REPO/ere-base-${{ inputs.zkvm }}:$CACHED_IMAGE_VERSION"
          CLI_ZKVM_IMAGE_TAG="$IMAGE_REPO/ere-cli-${{ inputs.zkvm }}:$CACHED_IMAGE_VERSION"

          echo "image_version=$IMAGE_VERSION" >> $GITHUB_OUTPUT
          echo "base_image_tag=$BASE_IMAGE_TAG" >> $GITHUB_OUTPUT
          echo "base_zkvm_image_tag=$BASE_ZKVM_IMAGE_TAG" >> $GITHUB_OUTPUT
          echo "cli_zkvm_image_tag=$CLI_ZKVM_IMAGE_TAG" >> $GITHUB_OUTPUT

      - name: Build ere-base image
        if: (github.event_name == 'push' && github.ref == 'refs/heads/master') || (github.event.pull_request.head.repo.full_name == github.repository && steps.changed_files.outputs.any_changed == 'true')
        uses: docker/build-push-action@v6
        with:
          context: .
          file: docker/base/Dockerfile.base
          push: true
          tags: ${{ steps.image_tag.outputs.base_image_tag }}

      - name: Build ere-base-${{ inputs.zkvm }} image
        if: (github.event_name == 'push' && github.ref == 'refs/heads/master') || (github.event.pull_request.head.repo.full_name == github.repository && steps.changed_files.outputs.any_changed == 'true')
        uses: docker/build-push-action@v6
        with:
          context: .
          file: docker/${{ inputs.zkvm }}/Dockerfile
          push: true
          tags: ${{ steps.image_tag.outputs.base_zkvm_image_tag }}
          build-args: |
            BASE_IMAGE_TAG=${{ steps.image_tag.outputs.base_image_tag }}
            CI=1

      - name: Build ere-cli-${{ inputs.zkvm }} image
        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
        uses: docker/build-push-action@v6
        with:
          context: .
          file: docker/cli/Dockerfile
          push: true
          tags: ${{ steps.image_tag.outputs.cli_zkvm_image_tag }}
          build-args: |
            BASE_ZKVM_IMAGE_TAG=${{ steps.image_tag.outputs.base_zkvm_image_tag }}
            ZKVM=${{ inputs.zkvm }}
            RUSTFLAGS=
            CI=1

  clippy_via_docker:
    name: Clippy via Docker
    needs: build_image
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Cache dependencies
        uses: Swatinem/rust-cache@v2
        with:
          key: rust-${{ inputs.toolchain }}-${{ inputs.zkvm }}-${{ hashFiles('Cargo.lock') }}

      - name: Pull images or build locally
        run: |
          # Pull or build ere-base-${{ inputs.zkvm }} locally
          if ! docker image pull ${{ needs.build_image.outputs.base_zkvm_image_tag }}; then
            echo "Building ere-base"
            docker build \
              --file docker/base/Dockerfile.base \
              --tag ${{ needs.build_image.outputs.base_image_tag }} \
              .

            echo "Building ere-base-${{ inputs.zkvm }}"
            docker build \
              --file docker/${{ inputs.zkvm }}/Dockerfile \
              --tag ${{ needs.build_image.outputs.base_zkvm_image_tag }} \
              --build-arg BASE_IMAGE_TAG=${{ needs.build_image.outputs.base_image_tag }} \
              --build-arg CI=1 \
              .
          fi

      - name: Run cargo clippy for ere-${{ inputs.zkvm }} via Docker
        run: |
          DOCKER_CMD="docker run \
            --rm \
            --interactive \
            --volume ${{ github.workspace }}:/ere \
            --volume $HOME/.cargo:/root/.cargo \
            --workdir /ere \
            ${{ needs.build_image.outputs.base_zkvm_image_tag }} \
            /bin/bash"

          cat <<EOF | $DOCKER_CMD
          set -e

          OPTIONS="--all-targets ${{ inputs.default_features && '' || '--no-default-features' }} -- -D warnings"
          cargo clippy --package ere-${{ inputs.zkvm }} \$OPTIONS
          cargo clippy --package ere-cli --features cli,${{ inputs.zkvm }} \$OPTIONS

          chown -R $(id -u):$(id -g) ~/.cargo
          chown -R $(id -u):$(id -g) target
          EOF

  test_via_docker:
    name: Test via Docker
    needs: build_image
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Cache dependencies
        uses: Swatinem/rust-cache@v2
        with:
          key: rust-${{ inputs.toolchain }}-${{ inputs.zkvm }}-${{ hashFiles('Cargo.lock') }}

      - name: Pull images or build locally
        run: |
          # Pull or build ere-base-${{ inputs.zkvm }} locally
          if ! docker image pull ${{ needs.build_image.outputs.base_zkvm_image_tag }}; then
            echo "Building ere-base"
            docker build \
              --file docker/base/Dockerfile.base \
              --tag ${{ needs.build_image.outputs.base_image_tag }} \
              .

            echo "Building ere-base-${{ inputs.zkvm }}"
            docker build \
              --file docker/${{ inputs.zkvm }}/Dockerfile \
              --tag ${{ needs.build_image.outputs.base_zkvm_image_tag }} \
              --build-arg BASE_IMAGE_TAG=${{ needs.build_image.outputs.base_image_tag }} \
              --build-arg CI=1 \
              .
          fi

      - name: Run cargo test for ere-${{ inputs.zkvm }} via Docker
        run: |
          DOCKER_CMD="docker run \
            --rm \
            --interactive \
            --volume ${{ github.workspace }}:/ere \
            --volume $HOME/.cargo:/root/.cargo \
            --workdir /ere \
            ${{ needs.build_image.outputs.base_zkvm_image_tag }} \
            /bin/bash"

          cat <<EOF | $DOCKER_CMD
          set -e -o pipefail

          CARGO_BUILD_CMD="cargo test --release --package ere-${{ inputs.zkvm }} \
            ${{ inputs.default_features && '' || '--no-default-features' }} \
            --no-run --message-format json"
          EXEC=\$(RUSTFLAGS=-Ctarget-cpu=native \$CARGO_BUILD_CMD \
            | jq -r 'select(.executable) | select(.package_id | contains("ere-${{ inputs.zkvm }}")) | .executable')
          \$EXEC ${{ inputs.test_options }}

          chown -R $(id -u):$(id -g) ~/.cargo
          chown -R $(id -u):$(id -g) target
          EOF

  test_ere_dockerized:
    name: Test ere-dockerized with the selected zkVM
    needs: build_image
    if: ${{ inputs.test_ere_dockerized }}
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ inputs.toolchain }}

      - name: Cache dependencies
        uses: Swatinem/rust-cache@v2
        with:
          key: rust-${{ inputs.toolchain }}-${{ inputs.zkvm }}-${{ hashFiles('Cargo.lock') }}

      - name: Pull images or build locally
        run: |
          # Pull or build ere-base locally
          if ! docker image pull ${{ needs.build_image.outputs.base_image_tag }}; then
            echo "Building ere-base"
            docker build \
              --file docker/base/Dockerfile.base \
              --tag ${{ needs.build_image.outputs.base_image_tag }} \
              .
          fi

          # Pull or build ere-base-${{ inputs.zkvm }} locally
          if ! docker image pull ${{ needs.build_image.outputs.base_zkvm_image_tag }}; then
            echo "Building ere-base-${{ inputs.zkvm }}"
            docker build \
              --file docker/${{ inputs.zkvm }}/Dockerfile \
              --tag ${{ needs.build_image.outputs.base_zkvm_image_tag }} \
              --build-arg BASE_IMAGE_TAG=${{ needs.build_image.outputs.base_image_tag }} \
              --build-arg CI=1 \
              .
          fi

          # Build ere-cli-${{ inputs.zkvm }}
          echo "Building ere-cli-${{ inputs.zkvm }}"
          docker build \
            --file docker/cli/Dockerfile \
            --tag ${{ needs.build_image.outputs.cli_zkvm_image_tag }} \
            --build-arg BASE_ZKVM_IMAGE_TAG=${{ needs.build_image.outputs.base_zkvm_image_tag }} \
            --build-arg ZKVM=${{ inputs.zkvm }} \
            --build-arg RUSTFLAGS='' \
            --build-arg CI=1 \
            .

          docker image tag ${{ needs.build_image.outputs.base_image_tag }} ere-base:${{ needs.build_image.outputs.image_version }}
          docker image tag ${{ needs.build_image.outputs.base_zkvm_image_tag }} ere-base-${{ inputs.zkvm }}:${{ needs.build_image.outputs.image_version }}
          docker image tag ${{ needs.build_image.outputs.cli_zkvm_image_tag }} ere-cli-${{ inputs.zkvm }}:${{ needs.build_image.outputs.image_version }}

      - name: Run cargo test for ere-${{ inputs.zkvm }} via ere-dockerized
        run: cargo test --release --package ere-dockerized -- ${{ inputs.zkvm }}