build.yml

name: Build/Test/Release
on:
  push:
  merge_group:
    types: [checks_requested]
jobs:
  build:
    name: Build
    runs-on: ubuntu-latest-8-cores
    permissions:
      packages: write
      contents: read
    steps:
      - name: Checkout machine emulator source code
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build docker image
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          platforms: linux/amd64,linux/arm64
          tags: ${{ github.repository_owner }}/machine-emulator:devel.build
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build debian package (amd64)
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: debian-packager
          platforms: linux/amd64
          tags: cartesi/machine-emulator:amd64_deb
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Export deb package artifact (amd64)
        run: make copy BUILD_PLATFORM=linux/amd64 DEB_ARCH=amd64 DEBIAN_IMG=cartesi/machine-emulator:amd64_deb

      - name: Build debian package (arm64)
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: debian-packager
          platforms: linux/arm64
          tags: cartesi/machine-emulator:arm64_deb
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Export deb package artifact (arm64)
        run: make copy BUILD_PLATFORM=linux/arm64 DEB_ARCH=arm64 DEBIAN_IMG=cartesi/machine-emulator:arm64_deb

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: artifacts
          path: |
            uarch-ram.bin
            uarch-pristine-ram.c
            uarch-pristine-hash.c
            machine-c-version.h
            cartesi-machine-v${{ env.MACHINE_EMULATOR_VERSION }}_amd64.deb
            cartesi-machine-v${{ env.MACHINE_EMULATOR_VERSION }}_arm64.deb

  test_amd64:
    name: Test (linux/amd64)
    needs: build
    runs-on: ubuntu-latest-8-cores
    steps:
      - name: Checkout machine emulator source code
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build machine-emulator "builder" docker image
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:builder
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator docker image
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:devel
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:tests
          push: false
          load: true
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: Simple boot inside the docker image
        run: docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/bin/cartesi-machine /bin/true

      - name: Run test suite inside the docker image
        run: docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/bin/cartesi-machine-tests run

      - name: Save and Load
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-save-and-load.sh

      - name: Yield and Save
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-yield-and-save.sh

      - name: Run test scripts
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/run-lua-tests.sh

      - name: Run jsonrpc lua test scripts
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-jsonrpc-server.sh jsonrpc-remote-cartesi-machine cartesi-machine cartesi-machine-tests

      - name: Create cmio templates
        run: |
          docker run --rm -t -v cmio-templates:/tmp/cartesi-machine/tests/data cartesi/machine-emulator:tests /usr/share/cartesi-machine/tests/lua/create-machines.lua

      - name: Run cmio lua test scripts
        run: |
          docker run --rm -t -v cmio-templates:/tmp/cartesi-machine/tests/data cartesi/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-cmio.sh jsonrpc-remote-cartesi-machine cartesi-machine lua

      - name: Run Merkle tree tests
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests test-merkle-tree-hash --log2-root-size=30 --log2-leaf-size=12 --input=/usr/bin/test-merkle-tree-hash

      - name: Run C API tests
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests test-machine-c-api

      - name: Run rv64ui test suite on microarchitecture
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests uarch-riscv-tests run

      - name: Run test suite with Microarchitecture
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests cartesi-machine-tests --jobs=$(nproc) run_uarch

      - name: Run test suite with microarchitecture and host based interpreters comparing machine hashes at every step
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests cartesi-machine-tests --concurrency=update_merkle_tree:1 --test="^rv64ui.*$" --jobs=$(nproc) run_host_and_uarch

      - name: Create uarch json logs to be used to test the Solidity based microarchitecture interpreter
        run: |
          docker run --name uarch-logs -w /tmp -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/collect-uarch-test-logs.sh
          docker cp uarch-logs:/tmp/uarch-riscv-tests-json-logs.tar.gz .
          docker rm uarch-logs

      - name: Upload uarch json logs to be used to test the Solidity based microarchitecture interpreter
        uses: actions/upload-artifact@v4
        with:
          name: uarch-logs
          path: uarch-riscv-tests-json-logs.tar.gz
          compression-level: 0

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          target: tests-debian-packager
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:tests-debian-packager
          push: false
          load: true
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: Test microarchitecture interpreter
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:tests-debian-packager make test-uarch-interpreter

      - name: Copy tests debian package
        run: make copy-tests-debian-packages

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: tests-amd64
          path: |
            cartesi-machine-tests-v${{ env.MACHINE_EMULATOR_VERSION }}_amd64.deb
            cartesi-machine-tests-data-v${{ env.MACHINE_EMULATOR_VERSION }}.deb

  test_arm64:
    name: Test (linux/arm64)
    needs: build
    runs-on: ubuntu-latest-8-cores
    steps:
      - name: Checkout machine emulator source code
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build docker image
        id: docker_build
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: builder
          platforms: linux/arm64
          tags: ${{ github.repository_owner }}/machine-emulator:builder
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator docker image
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          platforms: linux/arm64
          tags: ${{ github.repository_owner }}/machine-emulator:devel
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          platforms: linux/arm64
          tags: ${{ github.repository_owner }}/machine-emulator:tests
          push: false
          load: true
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: Simple boot inside the docker image
        run: docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/bin/cartesi-machine /bin/true

      - name: Run test suite inside the docker image
        run: docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/bin/cartesi-machine-tests run

      - name: Save and Load
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-save-and-load.sh

      - name: Yield and Save
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-yield-and-save.sh

      - name: Run test scripts
        run: |
          docker run --platform linux/arm64 --rm -t -e "CARTESI_CONCURRENCY_UPDATE_MERKLE_TREE=1" ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/run-lua-tests.sh

      - name: Run jsonrpc lua test scripts
        run: |
          docker run --platform linux/arm64 --rm -t -e "CARTESI_CONCURRENCY_UPDATE_MERKLE_TREE=1" ${{ github.repository_owner }}/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-jsonrpc-server.sh jsonrpc-remote-cartesi-machine cartesi-machine cartesi-machine-tests

      - name: Create cmio templates
        run: |
          docker run --platform linux/arm64 --rm -t -v cmio-templates:/tmp/cartesi-machine/tests/data cartesi/machine-emulator:tests /usr/share/cartesi-machine/tests/lua/create-machines.lua

      - name: Run cmio lua test scripts
        run: |
          docker run --platform linux/arm64 --rm -t -v cmio-templates:/tmp/cartesi-machine/tests/data cartesi/machine-emulator:tests /usr/share/cartesi-machine/tests/scripts/test-cmio.sh jsonrpc-remote-cartesi-machine cartesi-machine lua

      - name: Run Merkle tree tests
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests test-merkle-tree-hash --log2-root-size=30 --log2-leaf-size=12 --input=/usr/bin/test-merkle-tree-hash

      - name: Run C API tests
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests test-machine-c-api

      - name: Run rv64ui test suite on microarchitecture
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests uarch-riscv-tests run

      - name: Run test suite with Microarchitecture
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests cartesi-machine-tests --jobs=$(nproc) run_uarch

      - name: Run test suite with microarchitecture and host based interpreters comparing machine hashes at every step
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests cartesi-machine-tests  --test="^rv64ui%-v%-add.bin$" --concurrency=update_merkle_tree:1 --jobs=$(nproc) run_host_and_uarch

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          target: tests-debian-packager
          platforms: linux/arm64
          tags: ${{ github.repository_owner }}/machine-emulator:tests-debian-packager
          push: false
          load: true
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: Test microarchitecture interpreter
        run: |
          docker run --platform linux/arm64 --rm -t ${{ github.repository_owner }}/machine-emulator:tests-debian-packager make test-uarch-interpreter

      - name: Copy tests debian package
        run: make copy-tests-debian-packages BUILD_PLATFORM=linux/arm64 DEB_ARCH=arm64

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: tests-arm64
          path: |
            cartesi-machine-tests-v${{ env.MACHINE_EMULATOR_VERSION }}_arm64.deb

  static-analysis:
    name: Static Analysis
    needs: build
    runs-on: ubuntu-latest-8-cores
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build docker image
        id: docker_build
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:devel
          push: false
          load: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Check format (C++)
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:devel make check-format

      - name: Check format (Lua)
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:devel make check-format-lua

      - name: Lint (C++)
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:devel make -j$(nproc) lint

      - name: Lint (Lua)
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:devel make check-lua

  coverage:
    name: Coverage
    runs-on: ubuntu-latest-8-cores
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build docker image
        id: docker_build
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:builder
          push: false
          load: true
          cache-from: type=gha,scope=debian-coverage
          cache-to: type=gha,mode=max,scope=debian-coverage
          build-args: |
            GIT_COMMIT=${GITHUB_SHA}
            DEBUG=yes
            COVERAGE=yes
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          target: tests-builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:coverage
          push: false
          load: true
          build-args: |
            DEBUG=yes
            COVERAGE=yes
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: Run coverage
        run: |
          docker run --name coverage-report -t ${{ github.repository_owner }}/machine-emulator:coverage make -j1 test-save-and-load test-machine test-hash test-lua test-jsonrpc test-c-api coverage-machine test-uarch-rv64ui test-uarch-interpreter coverage-uarch coverage-report coverage=yes
          docker cp coverage-report:/usr/src/emulator/tests/build/coverage .
          docker rm coverage-report

      - name: Show coverage summary
        run: cat coverage/coverage.txt

      - name: Show uncovered lines
        if: false
        run: grep -F -e "=====:" -e "#####:" coverage/gcc/*.gcov

      - name: Upload coverage detailed report
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: coverage

  sanitize:
    name: Sanitize
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

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

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build docker image
        id: docker_build
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          target: builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:builder
          push: false
          load: true
          cache-from: type=gha,scope=debian-sanitize
          cache-to: type=gha,mode=max,scope=debian-sanitize
          build-args: |
            DEBUG=yes
            GIT_COMMIT=${GITHUB_SHA}
            SANITIZE=yes
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Build machine-emulator "tests" docker image
        uses: docker/build-push-action@v5
        with:
          file: tests/Dockerfile
          context: .
          target: tests-builder
          platforms: linux/amd64
          tags: ${{ github.repository_owner }}/machine-emulator:sanitizer
          push: false
          load: true
          build-args: |
            DEBUG=yes
            SANITIZE=yes
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}

      - name: MMAP rnd_bits workaround for the new GitHub ubuntu-22 runner
        run: sudo sysctl vm.mmap_rnd_bits=28

      - name: Run tests with sanitizer
        run: |
          docker run --rm -t ${{ github.repository_owner }}/machine-emulator:sanitizer make sanitize=yes test-save-and-load test-machine test-hash test-lua test-jsonrpc test-c-api coverage-machine test-uarch-rv64ui test-uarch-interpreter coverage-uarch

  publish_artifacts:
    name: Publish artifacts
    needs: [build, static-analysis, coverage, sanitize, test_amd64, test_arm64]
    runs-on: ubuntu-22.04
    steps:
      - name: Checkout emulator source code
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup variables
        run: echo MACHINE_EMULATOR_VERSION=`make version` >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

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

      - name: Setup debian docker image tags
        id: docker_image_tags
        uses: docker/metadata-action@v4
        with:
          images: |
            ghcr.io/${{ github.repository_owner }}/machine-emulator
            docker.io/${{ github.repository_owner }}/machine-emulator,enable=${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/') || startsWith(github.ref, 'refs/tags/v') }}
          tags: |
            type=ref,event=branch
            type=semver,pattern={{version}},enable=${{startsWith(github.ref, 'refs/tags/v')}}

      - name: Set up Depot CLI
        uses: depot/setup-action@v1

      - name: Build debian based docker image
        uses: depot/build-push-action@v1
        with:
          file: Dockerfile
          context: .
          platforms: linux/amd64,linux/arm64
          tags: ${{ steps.docker_image_tags.outputs.tags }}
          push: true
          cache-from: type=gha,scope=debian
          cache-to: type=gha,mode=max,scope=debian
          build-args: |
            DEBUG=${{ (startsWith(github.ref, 'refs/tags/v') && 'no' || 'yes') }}
            GIT_COMMIT=${GITHUB_SHA}
            MACHINE_EMULATOR_VERSION=${{ env.MACHINE_EMULATOR_VERSION }}
          project: ${{ vars.DEPOT_PROJECT }}
          token: ${{ secrets.DEPOT_TOKEN }}

      - name: Download artifacts
        uses: actions/download-artifact@v4
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}

      - name: Create uarch json logs TAR
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        run: mv uarch-logs/uarch-riscv-tests-json-logs.tar.gz uarch-logs/uarch-riscv-tests-json-logs-v${{ env.MACHINE_EMULATOR_VERSION }}.tar.gz

      - name: Create generated files patch
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        run: |
          mv artifacts/machine-c-version.h src
          mv artifacts/uarch-pristine-ram.c uarch
          mv artifacts/uarch-pristine-hash.c uarch
          make create-generated-files-patch

      - name: Upload products to GitHub Release
        uses: softprops/action-gh-release@v1
        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
        with:
          draft: true
          files: |
            artifacts/cartesi-machine-*.deb
            artifacts/uarch-ram.bin
            add-generated-files.diff
            uarch-logs/uarch-riscv-tests-json-logs-*.tar.gz
            tests-amd64/cartesi-machine-tests-*.deb
            tests-arm64/cartesi-machine-tests-*.deb