dapps.yml

name: dApps testing
run-name: dApps testing (${{ github.event.inputs.dapps || 'all dapps'}}, ${{ github.event.inputs.network || 'aws' }})

on:
  schedule:
    - cron: "0 1 * * 6"
  workflow_dispatch:
    inputs:
      network:
        type: choice
        default: aws
        required: true
        description: "Stand name"
        options:
          - night-stand
          - devnet
          - aws
          - custom
      dapps:
        type: string
        required: false
        description: "List of dapps separated by commas (if empty, all will be run)"
      proxy_url:
        type: string
        required: false
        description: "proxy_url (fill only for custom stand)"
      solana_url:
        type: string
        required: false
        description: "solana_url (fill only for custom stand)"
      faucet_url:
        type: string
        required: false
        description: "faucet_url (fill only for custom stand)"
      network_id:
        type: string
        required: false
        description: "network_id (fill only for custom stand)"
      pr_url_for_report:
        type: string
        required: false
        description: "Url to send the report as comment for PR"
env:
  AWS_ACCESS_KEY_ID: ${{ secrets.DAPPS_AWS_ACCESS_KEY_ID }}
  AWS_SECRET_ACCESS_KEY: ${{ secrets.DAPPS_AWS_SECRET_ACCESS_KEY }}
  AWS_REGION: us-east-2
  AWS_S3_BUCKET: neon-tests-dapps
  BUILD_URL: "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
  ALL_DAPPS: "aave,curve,uniswap-v2,uniswap-v3,saddle,yearn,robonomics,compound,curve-factory"
jobs:
  prepare:
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v3
      - name: Define dapps to run
        id: dapps
        run: |
          if [[ "${{ github.event.inputs.dapps }}" != "" ]]; then
            list=${{ github.event.inputs.dapps }}
          else
            list=${{env.ALL_DAPPS}}
          fi;
          echo "list=${list}"
          echo "list=${list}" >> $GITHUB_OUTPUT

      - name: Define network
        id: stand
        run: |
          if [[ "${{ github.event.inputs.network }}" != "" ]]; then
            network=${{ github.event.inputs.network }}
          else
            network=aws
          fi;
          echo "network=${network}"
          echo "network=${network}" >> $GITHUB_OUTPUT

      - name: Install terraform
        id: terraform
        if: steps.stand.outputs.network == 'aws'
        run: |
          sudo apt-get update && sudo apt-get install -y python-dev gnupg software-properties-common wget jq
          wget -O- https://apt.releases.hashicorp.com/gpg | \
              gpg --dearmor | \
              sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
          gpg --no-default-keyring \
              --keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \
              --fingerprint
          echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
              https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
              sudo tee /etc/apt/sources.list.d/hashicorp.list
          sudo apt update
          sudo apt-get install terraform


      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Deploy stand with terraform
        id: deploy
        if: steps.stand.outputs.network == 'aws'
        run: |
          ssh_key=/tmp/dapps-stand
          echo "${{ secrets.SSH_DAPPS_PRIVATE_KEY }}" >> ${ssh_key} && chmod 400 ${ssh_key}
          python3 ./clickfile.py infra deploy
      - uses: actions/upload-artifact@v3
        if: steps.stand.outputs.network == 'aws'
        with:
          name: tf-state
          path: deploy/aws/

      - name: Set outputs
        id: share
        env:
          SOLANA_IP: ${{ env.SOLANA_IP }}
          PROXY_IP: ${{ env.PROXY_IP }}
        run: |
          if [[ "${{steps.stand.outputs.network}}" == "custom" ]]; then
            proxy_url=${{ github.event.inputs.proxy_url }}
            faucet_url=${{ github.event.inputs.faucet_url }}
            solana_url=${{ github.event.inputs.solana_url }}
            network_id=${{ github.event.inputs.network_id }}
          else
            proxy_url=`python ./clickfile.py infra print-network-param -n '${{steps.stand.outputs.network}}' -p 'proxy_url'`
            solana_url=`python ./clickfile.py infra print-network-param -n '${{steps.stand.outputs.network}}' -p 'solana_url'`
            faucet_url=`python ./clickfile.py infra print-network-param -n '${{steps.stand.outputs.network}}' -p 'faucet_url'`
            network_id=`python ./clickfile.py infra print-network-param -n '${{steps.stand.outputs.network}}' -p 'network_ids.neon'`
          fi;
          
          if [[ "${{steps.stand.outputs.network}}" == "devnet" ]]; then
            solana_url="${{ secrets.SOLANA_URL }}"
          fi;
          echo "proxy_url=$proxy_url"
          echo "solana_url=$solana_url"
          echo "faucet_url=$faucet_url"
          echo "network_id=$network_id"
          echo "proxy_url=$proxy_url" >> $GITHUB_OUTPUT
          echo "solana_url=$solana_url" >> $GITHUB_OUTPUT
          echo "faucet_url=$faucet_url" >> $GITHUB_OUTPUT
          echo "network_id=$network_id" >> $GITHUB_OUTPUT

      - name: Wait until proxy is ready
        timeout-minutes: 5
        run: |
            while [[ "$(curl -s -X POST -o /dev/null -w ''%{http_code}'' ${{ steps.share.outputs.proxy_url }})" != "200" ]];
              do echo  "Proxy is not ready yet. Waiting 5 seconds...";
              sleep 5;
            done
    outputs:
      solana_url: ${{ steps.share.outputs.solana_url }}
      proxy_url: ${{ steps.share.outputs.proxy_url }}
      faucet_url: ${{ steps.share.outputs.faucet_url }}
      network_id: ${{ steps.share.outputs.network_id }}
      network: ${{ steps.stand.outputs.network }}
      dapps: ${{ steps.dapps.outputs.list }}

  uniswap-v2:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'uniswap-v2')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 3 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch uniswap v2 tests
        if: ${{ steps.accounts.outcome == 'success' }}
        timeout-minutes: 30
        id: uniswap-v2
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/uniswap-v2:latest
        run: |
          test -t 1 && USE_TTY="-t"
          docker pull ${{ env.IMAGE }}
          docker run -i ${USE_TTY} --name=uniswap-v2-${{ github.run_id }} \
            -e NEON_PROXY_URL=${{ env.PROXY_URL }} \
            -e NEON_ACCOUNTS=${{ env.ACCOUNTS }} \
            -e NEON_CHAIN_ID=${{ env.NETWORK_ID }} \
            --entrypoint /bin/bash ${{ env.IMAGE }} \
            -c "npx hardhat run /usr/src/app/scripts/deploy.ts"
          docker cp uniswap-v2-${{ github.run_id }}:/usr/src/app/report.json uniswap-v2-report.json
          docker rm -f uniswap-v2-${{ github.run_id }}

      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: uniswap-v2-report
          path: uniswap-v2-report.json

  uniswap-v3:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'uniswap-v3')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 3 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch uniswap v3 tests
        if: ${{ steps.accounts.outcome == 'success'}}
        id: uniswap-v3
        timeout-minutes: 30
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/uniswap-v3:latest
        run: |
          test -t 1 && USE_TTY="-t"
          docker pull ${{ env.IMAGE }}
          docker run -i ${USE_TTY} --name=uniswap-v3-${{ github.run_id }} \
            -e NEON_PROXY_URL=${{ env.PROXY_URL }} \
            -e NEON_ACCOUNTS=${{ env.ACCOUNTS }} \
            -e NEON_CHAIN_ID=${{ env.NETWORK_ID }} \
            ${{ env.IMAGE }}
          docker cp uniswap-v3-${{ github.run_id }}:/usr/src/app/report.json uniswap-v3-report.json
          docker rm -f uniswap-v3-${{ github.run_id }}

      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: uniswap-v3-report
          path: uniswap-v3-report.json

  saddle:
    runs-on: neon-hosted
    if: contains( needs.prepare.outputs.dapps, 'saddle')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 4 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch saddle tests
        if: ${{ steps.accounts.outcome == 'success' }}
        id: saddle
        timeout-minutes: 60
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/saddle_tests:latest
        run: |
          docker pull ${{ env.IMAGE }}
          docker run -i -d --name=saddle-${{ github.run_id }} ${{ env.IMAGE }} /bin/bash
          env_args="-e NEON_PROXY_URL=${{env.PROXY_URL}} -e NEON_ACCOUNTS=${{ env.ACCOUNTS }} -e NEON_CHAIN_ID=${{ env.NETWORK_ID }}"
          echo "Run Saddle 2 tokens pool tests"
          docker exec -i $env_args saddle-${{ github.run_id }} npx hardhat run /usr/src/app/scripts/deploy2Tokens.ts
          echo "Run Saddle 3 tokens pool tests"
          docker exec -i $env_args saddle-${{ github.run_id }} npx hardhat run /usr/src/app/scripts/deploy3Tokens.ts
          echo "Run Saddle MetaPool tests"
          docker exec -i $env_args saddle-${{ github.run_id }} npx hardhat run /usr/src/app/scripts/deployMetaPool.ts
          docker cp saddle-${{ github.run_id }}:/usr/src/app/report.json saddle-report.json
          docker rm -f saddle-${{ github.run_id }}

      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: saddle-report
          path: saddle-report.json
  aave:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'aave')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 5 -a 20000 -n ${{env.NETWORK_NAME}}

      - name: Launch aave tests
        if: ${{ steps.accounts.outcome == 'success' }}
        id: aave
        timeout-minutes: 60
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/aave_tests:latest
        run: |
          docker pull ${{ env.IMAGE }} 
          docker run -i -d --name=aave-${{ github.run_id }} ${{ env.IMAGE }} /bin/bash
          docker exec -i -e NEON_PROXY_URL=${{env.PROXY_URL}} -e NEON_ACCOUNTS=${{ env.ACCOUNTS }} -e NEON_CHAIN_ID=${{ env.NETWORK_ID }} aave-${{ github.run_id }} npm run neonlabs:deploy --network=neonlabs
          docker cp aave-${{ github.run_id }}:/app/report.json aave-report.json
          docker rm -f aave-${{ github.run_id }}
      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: aave-report
          path: aave-report.json
  curve:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'curve')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 8 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch curve tests
        id: curve
        timeout-minutes: 60
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/curve_tests:latest
        run: |
          docker pull ${{ env.IMAGE }}
          docker run -i -d --name curve-${{ github.run_id }} ${{ env.IMAGE }} /bin/bash
          test -t 1 && USE_TTY="-t"
          docker exec -i ${USE_TTY} curve-${{ github.run_id }} \
              brownie networks add live neon host="${{ env.PROXY_URL }}" chainid=${{env.NETWORK_ID}}  explorer=https://neonscan.org timeout=60
          docker exec -i ${USE_TTY} -e ACCOUNTS=${{ env.ACCOUNTS }} curve-${{ github.run_id }} \
            bash -c " \
              brownie test \
              -vvvv --network neon"
          docker cp curve-${{ github.run_id }}:/app/curve-report.json curve-report.json
          docker rm -f curve-${{ github.run_id }}
      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: curve-report
          path: curve-report.json
  curve-factory:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'curve-factory')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Run deployment
        timeout-minutes: 10
        run: |
          python3 scripts/curve-deploy.py

      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: curve-factory-report
          path: curve-factory-report.json

  compound:
    runs-on: ubuntu-20.04
    if: contains( needs.prepare.outputs.dapps, 'compound')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 2 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch compound tests
        timeout-minutes: 30
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/compound_tests:latest
        run: |
          docker pull ${{ env.IMAGE }}
          docker run -i -d --name compound-${{ github.run_id }} ${{ env.IMAGE }} /bin/bash
          test -t 1 && USE_TTY="-t"
          docker exec -i ${USE_TTY} compound-${{ github.run_id }} \
              brownie networks add live neon host="${{ env.PROXY_URL }}" chainid=${{env.NETWORK_ID}} timeout=60
          docker exec -i ${USE_TTY} -e ACCOUNTS=${{ env.ACCOUNTS }} compound-${{ github.run_id }} \
            bash -c " \
              brownie test \
              -vvvv --network neon"
          docker cp compound-${{ github.run_id }}:/app/compound-report.json compound-report.json
          docker rm -f compound-${{ github.run_id }}
      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: compound-report
          path: compound-report.json

  robonomics:
    runs-on: neon-hosted
    if: contains( needs.prepare.outputs.dapps, 'robonomics')
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 3 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch robonomics tests
        if: ${{ steps.accounts.outcome == 'success' }}
        id: robonomics
        timeout-minutes: 60
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/robonomics_tests:latest
        run: |
          docker pull ${{ env.IMAGE }}
          docker run -i -d --entrypoint "sleep" --name=robonomics-${{ github.run_id }} ${{ env.IMAGE }} infinity
          env_args="-e NEON_PROXY_URL=${{env.PROXY_URL}} -e NEON_ACCOUNTS=${{ env.ACCOUNTS }} -e NEON_CHAIN_ID=${{ env.NETWORK_ID }}"
          echo "Run Robonomics tests"
          docker exec -i $env_args robonomics-${{ github.run_id }} ./run_tests.sh
          docker exec -i $env_args robonomics-${{ github.run_id }} node create_report.js
          docker exec -i $env_args robonomics-${{ github.run_id }} cat ./reports/report.json > robonomics-report.json
          docker rm -f robonomics-${{ github.run_id }}
      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: robonomics-report
          path: robonomics-report.json
  yearn:
    if: contains( needs.prepare.outputs.dapps, 'yearn')
    runs-on: neon-hosted
    needs:
      - prepare
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      FAUCET_URL: ${{ needs.prepare.outputs.faucet_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK_NAME: ${{ needs.prepare.outputs.network }}
      DUMP_ENVS: True
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements

      - name: Prepare accounts
        id: accounts
        run: |
          python3 ./clickfile.py infra gen-accounts -c 10 -a 10000 -n ${{env.NETWORK_NAME}}

      - name: Launch yearn tests
        id: yearn
        timeout-minutes: 60
        env:
          ACCOUNTS: ${{ env.ACCOUNTS }}
          IMAGE: ${{ vars.DOCKERHUB_ORG_NAME }}/yearn_tests:latest
        run: |
          docker pull ${{ env.IMAGE }}
          docker run -i -d --name yearn-${{ github.run_id }} ${{ env.IMAGE }} /bin/bash
          docker exec -i -e ACCOUNTS=${{ env.ACCOUNTS }} yearn-${{ github.run_id }} \
              brownie networks add live neon host="${{ env.PROXY_URL }}" chainid=${{env.NETWORK_ID}} timeout=60
          docker exec -i -e ACCOUNTS=${{ env.ACCOUNTS }} yearn-${{ github.run_id }} \
            bash -c " \
              brownie test \
                tests/functional -m ci \
              -vvvv --network neon"
          docker cp yearn-${{ github.run_id }}:/app/report.json yearn-report.json
          docker rm -f yearn-${{ github.run_id }}

      - name: Save report
        uses: actions/upload-artifact@v3
        with:
          name: yearn-report
          path: yearn-report.json

  swap-report:
    runs-on: ubuntu-20.04
    needs: [prepare, uniswap-v2, uniswap-v3, saddle, aave, curve, robonomics, yearn, compound, curve-factory]
    if: always()
    env:
      SOLANA_URL: ${{ needs.prepare.outputs.solana_url || secrets.SOLANA_URL }}
      PROXY_URL: ${{ needs.prepare.outputs.proxy_url }}
      NETWORK_ID: ${{ needs.prepare.outputs.network_id }}
      NETWORK: ${{ needs.prepare.outputs.network }}
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: uniswap-v2-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: uniswap-v3-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: saddle-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: yearn-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: aave-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: compound-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: curve-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: curve-factory-report
          path: reports/
      - uses: actions/download-artifact@v3
        continue-on-error: true
        with:
          name: robonomics-report
          path: reports/
      - name: "Swap report"
        run: |
          python3 ./clickfile.py dapps report --directory=reports \
          --pr_url_for_report=${{ github.event.inputs.pr_url_for_report }} \
          --token=${{secrets.GHTOKEN}}

  destroy:
    runs-on: ubuntu-20.04
    needs: [prepare, uniswap-v2, uniswap-v3, saddle, curve, aave, yearn, robonomics, swap-report, compound, curve-factory]
    if: always() && needs.prepare.outputs.network == 'aws'
    steps:
      - uses: actions/checkout@v3
      - uses: actions/download-artifact@v3
        with:
          name: tf-state
      - name: Install python requirements
        if: always()
        id: requirements
        uses: ./.github/actions/python-requirements
      - name: Prepare server for destroy terraform stand
        if: always()
        run: |
          sudo apt-get update && sudo apt-get install -y python-dev gnupg software-properties-common wget
          wget -O- https://apt.releases.hashicorp.com/gpg | \
              gpg --dearmor | \
              sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
          gpg --no-default-keyring \
              --keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \
              --fingerprint
          echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
              https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
              sudo tee /etc/apt/sources.list.d/hashicorp.list
          sudo apt update
          sudo apt-get install terraform
          ssh_key=/tmp/dapps-stand
          echo "${{ secrets.SSH_DAPPS_PRIVATE_KEY }}" >> ${ssh_key} && chmod 400 ${ssh_key}
      - name: Download docker logs
        run: python3 ./clickfile.py infra download-logs
      - name: Destroy stand with terraform
        id: destroy
        if: always()
        run: |
          python3 ./clickfile.py infra destroy
      - uses: actions/upload-artifact@v3
        if: always()
        with:
          name: AWS docker logs
          path: ./logs/*

  notify:
    runs-on: ubuntu-20.04
    needs: [prepare, uniswap-v2, uniswap-v3, saddle, aave, curve, robonomics, yearn, compound, curve-factory]
    if: failure() && github.ref_name == 'develop'
    steps:
      - uses: actions/checkout@v3
      - name: Install python requirements
        id: requirements
        uses: ./.github/actions/python-requirements
      - name: Notify on failure
        id: notification
        run: |
          python3 ./clickfile.py send-notification -u ${{ secrets.SLACK_QA_CHANNEL_URL }} -b ${{ env.BUILD_URL }} -t "DApps testing failed, please check!"