.gitlab-ci.yml

# .gitlab-ci.yml
#
# ink
#
# pipelines can be triggered manually in the web

default:
  retry:
    max: 2
    when:
      - runner_system_failure
      - unknown_failure
      - api_failure

stages:
  - lint
  - check
  - workspace
  - examples
  - ink-waterfall
  - fuzz
  - publish

variables:
  GIT_STRATEGY:                    fetch
  GIT_DEPTH:                       100
  CARGO_INCREMENTAL:               0
  CARGO_TARGET_DIR:                "/ci-cache/${CI_PROJECT_NAME}/targets/${CI_COMMIT_REF_NAME}/${CI_JOB_NAME}"
  # CI_IMAGE is changed to "-:staging" when the CI image gets rebuilt
  # read more https://github.com/paritytech/scripts/pull/244
  CI_IMAGE:                        "paritytech/ink-ci-linux:production"
  PURELY_STD_CRATES:               "ink/codegen metadata engine e2e e2e/macro ink/ir"
  ALSO_WASM_CRATES:                "env storage storage/traits allocator prelude primitives ink ink/macro"
  ALL_CRATES:                      "${PURELY_STD_CRATES} ${ALSO_WASM_CRATES}"
  MULTI_CONTRACT_CALLER_SUBCONTRACTS: "accumulator adder subber"
  LANG_ERR_INTEGRATION_CONTRACTS:  "integration-flipper call-builder contract-ref constructors-return-value"
  # TODO `cargo clippy --verbose --all-targets --all-features` for this crate
  # currently fails on `stable`, but succeeds on `nightly`. This is due to
  # this fix not yet in stable: https://github.com/rust-lang/rust-clippy/issues/8895.
  # Remove the following line again as soon as `clippy` on stable succeeds again.
  CLIPPY_ALLOWED:                  "clippy::extra_unused_lifetimes"
  # We plan to fully support RISC-V as a bytecode for contracts soon.
  # RISC-V does not have a standard library in contrast to Wasm. Compiling against
  # this target also makes sure that we don't pull in `std` by accident (through dependencies).
  # RISC-V is a modular archtitecture. We might switch to a different flavor with more features
  # later. For example, `riscv32imc-unknown-none-elf`.
  RISCV_TARGET:                   "riscv32i-unknown-none-elf"

workflow:
  rules:
    - if: $CI_COMMIT_TAG
    - if: $CI_COMMIT_BRANCH

.collect-artifacts:                &collect-artifacts
  artifacts:
    name:                          "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}"
    when:                          on_success
    expire_in:                     7 days
    paths:
      - artifacts/

.rust-info-script:                 &rust-info-script
  - rustup show
  - cargo --version
  - rustup +nightly show
  - cargo +nightly --version
  - cargo spellcheck --version
  - bash --version

.test-refs:                        &test-refs
  rules:
    - if: $CI_PIPELINE_SOURCE == "web"
    - if: $CI_PIPELINE_SOURCE == "schedule"
    - if: $CI_COMMIT_REF_NAME == "master"
    - if: $CI_COMMIT_REF_NAME == "tags"
    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/                         # PRs
    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/              # i.e. v1.0, v2.1rc1

.docker-env:                       &docker-env
  image:                           "${CI_IMAGE}"
  before_script:
    - *rust-info-script
  interruptible:                   true
  tags:
    - linux-docker-vm-c2

.kubernetes-env:                   &kubernetes-env
  interruptible:                   true
  tags:
    - kubernetes-parity-build

#### stage:                        lint
#
# Note: For all of these lints we `allow_failure` so that the rest of the build can
# continue running despite them not passing. Merging is still disallowed since (most) of
# the lint steps are marked as "Required" in GitHub.
spellcheck:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - cargo spellcheck check -v --cfg=.config/cargo_spellcheck.toml --checkers hunspell --code 1 -- recursive .
    - cargo spellcheck check -v --cfg=.config/cargo_spellcheck.toml --checkers hunspell --code 1 -- recursive ./integration-tests/*
  allow_failure:                   true

fmt:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - cargo +nightly fmt --verbose --all -- --check
    # For the UI tests we need to disable the license check
    - cargo +nightly fmt --verbose --all -- --check ./crates/ink/tests/ui/contract/{pass,fail}/*.rs
    - cargo +nightly fmt --verbose --all -- --check ./crates/ink/tests/ui/trait_def/{pass,fail}/*.rs
  allow_failure:                   true

examples-fmt:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    # Note that we disable the license header check for the examples, since they are unlicensed.
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        cargo +nightly fmt --verbose --manifest-path ${example}/Cargo.toml -- --check;
      done
    - for contract in ${MULTI_CONTRACT_CALLER_SUBCONTRACTS}; do
        cargo +nightly fmt --verbose --manifest-path ./integration-tests/multi-contract-caller/${contract}/Cargo.toml -- --check;
      done
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo +nightly fmt --verbose --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml -- --check;
      done
    - cargo +nightly fmt --verbose --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml -- --check
    # This file is not a part of the cargo project, so it wouldn't be formatted the usual way
    - rustfmt +nightly --verbose --check ./integration-tests/psp22-extension/runtime/psp22-extension-example.rs
  allow_failure:                   true

clippy-std:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for crate in ${ALL_CRATES}; do
        cargo clippy --verbose --all-targets --all-features --manifest-path ./crates/${crate}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
      done

clippy-wasm:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for crate in ${ALSO_WASM_CRATES}; do
        cargo clippy --verbose --no-default-features --manifest-path ./crates/${crate}/Cargo.toml --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
      done
  allow_failure:                   true

examples-clippy-std:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        cargo clippy --verbose --all-targets --manifest-path ${example}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - for contract in ${MULTI_CONTRACT_CALLER_SUBCONTRACTS}; do
        cargo clippy --verbose --all-targets --manifest-path ./integration-tests/multi-contract-caller/${contract}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo clippy --verbose --all-targets --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - cargo clippy --verbose --all-targets --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
  allow_failure:                   true

examples-clippy-wasm:
  stage:                           lint
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        cargo clippy --verbose --manifest-path ${example}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - for contract in ${MULTI_CONTRACT_CALLER_SUBCONTRACTS}; do
        cargo clippy --verbose --manifest-path ./integration-tests/multi-contract-caller/${contract}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo clippy --verbose --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
      done
    - cargo clippy --verbose --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
  allow_failure:                   true


#### stage:                        check

check-std:
  stage:                           check
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for crate in ${ALL_CRATES}; do
        cargo check --verbose --all-features --manifest-path ./crates/${crate}/Cargo.toml;
      done

check-wasm:
  stage:                           check
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - for crate in ${ALSO_WASM_CRATES}; do
        cargo check --verbose --no-default-features --target wasm32-unknown-unknown --manifest-path ./crates/${crate}/Cargo.toml;
      done

check-riscv:
  stage:                           check
  <<:                              *docker-env
  <<:                              *test-refs
  variables:
    RUSTC_BOOTSTRAP:               "1"
  script:
    - for crate in ${ALSO_WASM_CRATES}; do
        cargo check --verbose --no-default-features --target $RISCV_TARGET -Zbuild-std="core,alloc" --manifest-path ./crates/${crate}/Cargo.toml;
      done

dylint:
    stage:                           check
    <<:                              *docker-env
    <<:                              *test-refs
    script:
    - cd linting/
    # we are using a toolchain file in this directory
    # add required components for CI
    - rustup component add rustfmt clippy
    - cargo check --verbose
    - cargo +nightly fmt --verbose --all -- --check
    - cargo clippy --verbose -- -D warnings;
    # Needed until https://github.com/mozilla/sccache/issues/1000 is fixed.
    - unset RUSTC_WRAPPER
    - cargo test --verbose --all-features

#### stage:                        workspace

build-std:
  stage:                           workspace
  <<:                              *docker-env
  <<:                              *test-refs
  needs:
    - job:                         check-std
      artifacts:                   false
  script:
    - for crate in ${ALL_CRATES}; do
        cargo build --verbose --all-features --release --manifest-path ./crates/${crate}/Cargo.toml;
      done

build-wasm:
  stage:                           workspace
  <<:                              *docker-env
  <<:                              *test-refs
  needs:
    - job:                         check-wasm
      artifacts:                   false
  script:
    - for crate in ${ALSO_WASM_CRATES}; do
        cargo build --verbose --no-default-features --release --target wasm32-unknown-unknown --manifest-path ./crates/${crate}/Cargo.toml;
      done

test:
  stage:                           workspace
  <<:                              *docker-env
  <<:                              *test-refs
  needs:
    - job:                         check-std
      artifacts:                   false
  variables:
      # Since we run the tests with `--all-features` this implies the feature
      # `ink-fuzz-tests` as well -- i.e. the fuzz tests are run.
      # There's no way to disable a single feature while enabling all features
      # at the same time, hence we use this workaround.
      QUICKCHECK_TESTS:            0
  script:
    - cargo test --verbose --all-features --no-fail-fast --workspace
    - cargo test --verbose --all-features --no-fail-fast --workspace --doc

docs:
  stage:                           workspace
  <<:                              *docker-env
  <<:                              *test-refs
  variables:
    RUSTDOCFLAGS: -Dwarnings
  artifacts:
    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}-doc"
    when: on_success
    expire_in: 7 days
    paths:
      - ./crate-docs/
  script:
    # All crate docs currently need to be built separately. The reason
    # is that `smart-bench-macro` is a dependency now in a number of places.
    # This crate uses e.g. `ink_metadata`, but in its published form. So if
    # e.g. the `-p ink_metadata` is added to the `ink_lang` command  this
    # results in the cargo failure "multiple packages with same spec, ambiguous".
    - cargo doc --no-deps --all-features -p ink_env
    - cargo doc --no-deps --all-features -p ink_storage
    - cargo doc --no-deps --all-features -p ink_storage_traits
    - cargo doc --no-deps --all-features -p ink_primitives
    - cargo doc --no-deps --all-features -p ink_prelude
    - cargo doc --no-deps --all-features -p ink
    - cargo doc --no-deps --all-features -p ink_macro
    - cargo doc --no-deps --all-features -p ink_ir
    - cargo doc --no-deps --all-features -p ink_codegen
    - cargo doc --no-deps --all-features -p ink_metadata
    - cargo doc --no-deps --all-features -p ink_e2e
    - cargo doc --no-deps --all-features -p ink_e2e_macro
    - mv ${CARGO_TARGET_DIR}/doc ./crate-docs
    # FIXME: remove me after CI image gets nonroot
    - chown -R nonroot:nonroot ./crate-docs


codecov:
  stage:                           workspace
  <<:                              *docker-env
  <<:                              *test-refs
  needs:
    - job:                         check-std
      artifacts:                   false
  variables:
    # For codecov it's sufficient to run the fuzz tests only once.
    QUICKCHECK_TESTS:              1
    INK_COVERAGE_REPORTING:        "true"
    CARGO_INCREMENTAL:             0
    # Needed because `codecov` requires nightly features to work
    # (see `-Z` in the `RUSTFLAGS` below).
    RUSTC_BOOTSTRAP:               "1"
    # Variables partly came from https://github.com/mozilla/grcov/blob/master/README.md
    RUSTFLAGS:                     "-Zprofile -Zmir-opt-level=0 -Ccodegen-units=1
                                    -Clink-dead-code -Copt-level=0 -Coverflow-checks=off"
    # The `cargo-taurpalin` coverage reporting tool seems to have better code instrumentation and thus
    # produces better results for Rust codebases in general. However, unlike `grcov` it requires
    # running docker with `--security-opt seccomp=unconfined` which is why we use `grcov` instead.
  before_script:
    - *rust-info-script
    # RUSTFLAGS are the cause target cache can't be used here
    # FIXME: cust-covfix doesn't support the external target dir
    # https://github.com/Kogia-sima/rust-covfix/issues/7
    - unset "CARGO_TARGET_DIR"
    - cargo clean
    # make sure there's no stale coverage artifacts
    - find . -name "*.profraw" -type f -delete
    - find . -name "*.gcda" -type f -delete
  script:
    # RUSTFLAGS are the cause target cache can't be used here
    - cargo build --verbose --all-features --workspace
    - cargo test --verbose --all-features --no-fail-fast --workspace
    # coverage with branches
    - grcov . --binary-path ./target/debug/ --source-dir . --output-type lcov --llvm --branch
        --ignore-not-existing --ignore "/*" --ignore "tests/*" --output-path lcov-w-branch.info
    - rust-covfix lcov-w-branch.info --output lcov-w-branch-fixed.info
    - codecov --token "$CODECOV_P_TOKEN" --file lcov-w-branch-fixed.info --nonZero
    # lines coverage
    - grcov . --binary-path ./target/debug/ --source-dir . --output-type lcov --llvm
        --ignore-not-existing --ignore "/*" --ignore "tests/*" --output-path lcov-lines.info
    - rust-covfix lcov-lines.info --output lcov-lines-fixed.info
    - codecov --token "$CODECOV_TOKEN" --file lcov-lines-fixed.info --nonZero


#### stage:                        examples

examples-test:
  stage:                           examples
  <<:                              *docker-env
  <<:                              *test-refs
  needs:
    - job:                         clippy-std
      artifacts:                   false
  script:
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        if [ "$example" = "integration-tests/conditional-compilation/" ]; then
        cargo test --verbose --manifest-path ${example}/Cargo.toml --features "foo";
        cargo test --verbose --manifest-path ${example}/Cargo.toml --features "bar";
        cargo test --verbose --manifest-path ${example}/Cargo.toml --features "foo, bar";
        fi;
        if grep -q "e2e-tests = \[\]" "${example}/Cargo.toml"; then
          cargo test --verbose --manifest-path ${example}/Cargo.toml --features e2e-tests;
        else
          cargo test --verbose --manifest-path ${example}/Cargo.toml;
        fi;
      done
    - for contract in ${MULTI_CONTRACT_CALLER_SUBCONTRACTS}; do
        cargo test --verbose --manifest-path ./integration-tests/multi-contract-caller/${contract}/Cargo.toml;
      done
    # TODO (#1502): We need to clean before running, otherwise the CI fails with a
    # linking error.
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo clean --verbose --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml;
        cargo test --verbose --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml --features e2e-tests;
      done
    - cargo test --verbose --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml;

examples-contract-build:
  stage:                           examples
  <<:                              *docker-env
  <<:                              *test-refs
  script:
    - rustup component add rust-src --toolchain stable
    - cargo contract -V
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        if [ "$example" = "integration-tests/conditional-compilation/" ]; then
        pushd $example &&
        cargo contract build --features "foo" &&
        popd;
        pushd $example &&
        cargo contract build --features "bar" &&
        popd;
        pushd $example &&
        cargo contract build --features "foo, bar" &&
        popd;
        fi;
        pushd $example &&
        cargo contract build &&
        popd;
      done
    - pushd ./integration-tests/multi-contract-caller/ && ./build-all.sh && popd
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo contract build --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml;
      done
    - cargo contract build --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml

# TODO: Use cargo contract as soon as it has RISC-V support
examples-contract-build-riscv:
  stage:                           examples
  <<:                              *docker-env
  <<:                              *test-refs
  variables:
    RUSTC_BOOTSTRAP:               "1"
  script:
    - rustup component add rust-src --toolchain stable
    - cargo contract -V
    # We skip some examples for those reasons:
    # There are no manifests in those two directories and hence it would fall back to the workspace.
    #  - lang-err-integration-tests
    #  - upgradeable-contracts
    # This uses dlmalloc which is only supported on select targets.
    #   - custom_allocator
    # Pulls in sp-std which needlessly requires atomic pointers (TODO: Fix sp-std and enable this example)
    #   - call-runtime
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        if [ "$example" = "integration-tests/upgradeable-contracts/" ]; then continue; fi;
        if [ "$example" = "integration-tests/custom-allocator/" ]; then continue; fi;
        if [ "$example" = "integration-tests/call-runtime/" ]; then continue; fi;
        pushd $example &&
        cargo build --no-default-features --target $RISCV_TARGET -Zbuild-std="core,alloc" &&
        popd;
      done

examples-docs:
  stage:                           examples
  <<:                              *docker-env
  <<:                              *test-refs
  variables:
    RUSTDOCFLAGS: -Dwarnings
  script:
    # `--document-private-items` needs to be in here because currently our contract macro
    # puts the contract functions in a private module.
    # Once https://github.com/paritytech/ink/issues/336 has been implemented we can get rid
    # of this flag.
    - for example in integration-tests/*/; do
        if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
        cargo doc --manifest-path ${example}/Cargo.toml --document-private-items --verbose --no-deps;
      done
    - for contract in ${MULTI_CONTRACT_CALLER_SUBCONTRACTS}; do
        cargo doc --manifest-path ./integration-tests/multi-contract-caller/${contract}/Cargo.toml --document-private-items --verbose --no-deps;
      done
    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
        cargo doc --manifest-path ./integration-tests/lang-err-integration-tests/${contract}/Cargo.toml --document-private-items --verbose --no-deps;
      done
    - cargo doc --manifest-path ./integration-tests/set-code-hash/updated-incrementer/Cargo.toml --document-private-items --verbose --no-deps


#### stage:                        ink-waterfall

# Disabled because `polkadot-js` doesn't support WeightsV2 for
# contracts yet.
.ink-waterfall:
  stage:                           ink-waterfall
  image:                           paritytech/tools:latest
  <<:                              *kubernetes-env
  <<:                              *test-refs
  variables:
    TRGR_PROJECT:                  ${CI_PROJECT_NAME}
    TRGR_REF:                      ${CI_COMMIT_REF_NAME}
    # The `ink-waterfall` project id in GitLab
    DWNSTRM_ID:                    409
  script:
    - ./scripts/ci/trigger_pipeline.sh
  allow_failure:                   true


#### stage:                        publish

publish-docs:
  stage:                           publish
  <<:                              *kubernetes-env
  image:                           paritytech/tools:latest
  needs:
    - job:                         docs
      artifacts:                   true
  variables:
    GIT_DEPTH:                     100
  rules:
    - if: $CI_PIPELINE_SOURCE == "web"
    - if: $CI_PIPELINE_SOURCE == "schedule"
      when: never
    - if: $CI_COMMIT_REF_NAME == "master"
    - if: $CI_COMMIT_REF_NAME == "tags"
  before_script:
    - unset CARGO_TARGET_DIR
  script:
    # Setup ssh
    - eval $(ssh-agent)
    - ssh-add - <<< ${GITHUB_SSH_PRIV_KEY}
    - mkdir ~/.ssh && touch ~/.ssh/known_hosts
    - ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
    # Set git config
    - git config user.email "${GITHUB_EMAIL}"
    - git config user.name "${GITHUB_USER}"
    - git config remote.origin.url "git@github.com:/paritytech/${CI_PROJECT_NAME}.git"
    - git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
    - git fetch origin gh-pages
    # saving README and docs
    - cp -r ./crate-docs/ /tmp/doc/
    - cp ./README.md /tmp/doc/
    - cp -r ./.images/ /tmp/doc/
    - git checkout gh-pages
    - mv _config.yml /tmp/doc/
    # remove everything and restore generated docs, README and Jekyll config
    - rm -rf ./*
    - rm -rf ./.images
    - mv /tmp/doc/* .
    - mv /tmp/doc/.images .
    # Upload files
    - git add --all --force
    - git status
    # `git commit` has an exit code of > 0 if there is nothing to commit.
    # This unfortunately causes GitLab to exit immediately and mark this
    # job as failed subsequently.
    # We don't want to mark the entire job as failed if there's nothing to
    # publish though, hence the `|| true`.
    - git commit -m "Updated docs for ${CI_COMMIT_REF_NAME} and pushed to gh-pages" || true
    - git push origin gh-pages --force
  after_script:
    - rm -rf .git/ ./*

#### stage:                        fuzz

# Temporarily disabled until https://github.com/paritytech/ink/issues/1374
# is fixed.
.fuzz-tests:
  stage:                           fuzz
  <<:                              *docker-env
  variables:
    # The QUICKCHECK_TESTS default is 100
    QUICKCHECK_TESTS:              5000
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule"
    - if: $CI_COMMIT_REF_NAME == "master"
  script:
    # We fuzz-test only crates which possess the `ink-fuzz-tests` feature
    - all_tests_passed=0
    - for crate in ${ALL_CRATES}; do
        if grep "ink-fuzz-tests =" ./crates/${crate}/Cargo.toml;
        then
          cargo test --verbose --features ink-fuzz-tests --manifest-path ./crates/${crate}/Cargo.toml --no-fail-fast -- fuzz_ || exit_code=$?;
          all_tests_passed=$(( all_tests_passed | exit_code ));
        fi
      done
    - if [ $all_tests_passed -eq 0 ]; then exit 0; fi
    - |
      curl -X "POST" "https://api.github.com/repos/paritytech/ink/issues" \
        -H "Cookie: logged_in=no" \
        -H "Authorization: token ${GITHUB_PR_TOKEN}" \
        -H "Content-Type: application/json; charset=utf-8" \
        -d $'{
            "title": "[ci] Failing fuzz tests on master ('"$( date +"%d %b %Y" )"')",
            "body": "The CI job ['"${CI_JOB_ID}"']('"${CI_JOB_URL}"') just failed.\n\nThe offending commit is ['"${CI_COMMIT_TITLE}"'](https://github.com/paritytech/ink/commit/'"${CI_COMMIT_SHA}"').",
            "assignees": [],
            "labels": [
                "P-high"
            ]
        }'
    - exit ${all_tests_passed}