action.yml

name: 'ZecKit E2E'
description: 'Standardized Zcash E2E test suite for GitHub CI'

inputs:
  backend:
    description: "Light-client backend: 'lwd' or 'zaino'"
    required: false
    default: 'zaino'
  startup_timeout_minutes:
    description: 'Minutes to wait for Zebra + Backend to reach health'
    required: false
    default: '20'
  block_wait_seconds:
    description: 'Seconds to wait after mining for propagation'
    required: false
    default: '75'
  send_amount:
    description: 'Amount in ZEC for the E2E golden flow transaction'
    required: false
    default: '0.05'
  send_memo:
    description: 'Memo string for the E2E golden flow transaction'
    required: false
    default: 'ZecKit E2E Transaction'
  upload_artifacts:
    description: "Artifact upload policy: 'always' | 'on-failure' | 'never'"
    required: false
    default: 'on-failure'
  ghcr_token:
    description: 'GitHub token for pulling/pushing images'
    required: false
  image_prefix:
    description: 'Custom prefix for docker images (if using local fork)'
    required: false
    default: ''
  allow_build:
    description: "Whether to allow building images from source if missing (default: true for stability)"
    required: false
    default: 'true'
  miner_address:
    description: 'Custom transparent address to receive Zebra mining rewards (uses embedded default if omitted)'
    required: false
    default: ''
  fund_address:
    description: 'Address to automatically fund after the devnet is healthy (skipped if omitted)'
    required: false
    default: ''
  fund_amount:
    description: 'Amount in ZEC to send to fund_address (default: 10.0)'
    required: false
    default: '10.0'
  only_setup:
    description: 'If true, skip the ZecKit smoke tests and only start the devnet'
    required: false
    default: 'false'
  block_interval:
    description: 'Custom block mining interval in seconds'
    required: false
    default: '15'
  activation_heights:
    description: 'Custom activation heights in key=value format (e.g. nu5=1,nu6=10)'
    required: false
    default: ''


outputs:
  unified_address:
    description: "Faucet's Unified Address"
    value: ${{ steps.e2e.outputs.unified_address }}
  shield_txid:
    description: 'TXID of the transparent-to-shielded transaction'
    value: ${{ steps.e2e.outputs.shield_txid }}
  send_txid:
    description: 'TXID of the E2E golden flow send'
    value: ${{ steps.e2e.outputs.send_txid }}
  final_orchard_balance:
    description: 'Final Orchard balance of the faucet wallet'
    value: ${{ steps.e2e.outputs.final_orchard_balance }}
  test_result:
    description: "Outcome of the E2E run: 'pass' | 'fail'"
    value: ${{ steps.e2e.outputs.test_result }}

runs:
  using: "composite"
  steps:
    - name: Set up environment
      shell: bash
      run: |
        echo "Starting ZecKit E2E Action..."
        echo "Backend: ${{ inputs.backend }}"
        echo "Action Path: ${{ github.action_path }}"
        echo "Action Ref: ${{ github.action_ref }}"

    - name: Detect platform
      id: platform
      shell: bash
      run: |
        if [[ "$RUNNER_OS" == "Linux" ]]; then
          echo "binary=zeckit-linux-x86_64" >> $GITHUB_OUTPUT
        elif [[ "$RUNNER_OS" == "macOS" ]]; then
          if [[ "$RUNNER_ARCH" == "ARM64" ]]; then
            echo "binary=zeckit-macos-aarch64" >> $GITHUB_OUTPUT
          else
            echo "binary=zeckit-macos-x86_64" >> $GITHUB_OUTPUT
          fi
        else
          echo "Unsupported OS: $RUNNER_OS"
          exit 1
        fi

    - name: Try to download prebuilt ZecKit CLI
      id: download
      continue-on-error: true
      shell: bash
      run: |
        VERSION="${{ github.action_ref }}"
        BINARY="${{ steps.platform.outputs.binary }}"

        # If VERSION is empty, it means we are using the action locally (self-test)
        # We should build from source to test the local CLI changes.
        if [[ -z "$VERSION" ]]; then
          echo "Local execution detected (action_ref is empty). Skipping download to build from source."
          echo "downloaded=false" >> $GITHUB_OUTPUT
          exit 0
        fi

        # Robustly detect the repository hosting the action (fork-safe)
        # GitHub checkouts actions into _actions/<owner>/<repo>/ref
        OWNER_REPO=$(echo "${{ github.action_path }}" | awk -F'/_actions/' '{print $2}' | cut -d'/' -f1,2)
        if [ -z "$OWNER_REPO" ]; then
           OWNER_REPO="zecdev/ZecKit" # Fallback to upstream
        fi

        BASE="https://github.com/${OWNER_REPO}/releases"

        mkdir -p "${{ github.action_path }}/bin"
        
        # Determine version for download
        if [[ "$VERSION" == "main" ]] || [[ "$VERSION" == "m3-implementation" ]]; then
          DL_URL="$BASE/latest/download/$BINARY"
        else
          # Clean version tag (strip 'refs/tags/' if present)
          TAG="${VERSION#refs/tags/}"
          DL_URL="$BASE/download/$TAG/$BINARY"
        fi

        echo "Attempting to download $DL_URL..."
        curl -L -f -o "${{ github.action_path }}/bin/zeckit" "$DL_URL"
        
        if [ $? -eq 0 ]; then
          chmod +x "${{ github.action_path }}/bin/zeckit"
          echo "✓ Successfully downloaded prebuilt binary"
          echo "downloaded=true" >> $GITHUB_OUTPUT
        else
          echo "⚠️ Prebuilt binary not found for version $VERSION. Will fall back to building from source."
          echo "downloaded=false" >> $GITHUB_OUTPUT
        fi

    - name: Build ZecKit CLI (Fallback)
      if: steps.download.outputs.downloaded != 'true'
      shell: bash
      run: |
        echo "Building ZecKit CLI from source..."
        cd ${{ github.action_path }}
        cargo build --locked -p zeckit
      
    - name: Registry Login
      if: inputs.ghcr_token != ''
      shell: bash
      run: |
        echo "${{ inputs.ghcr_token }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin

    - name: Run E2E Suite
      id: e2e
      shell: bash
      env:
        ZECKIT_ALLOW_BUILD: "${{ inputs.allow_build }}"
        ZECKIT_SRC_PATH: ${{ github.action_path }}
      run: |
        # Use downloaded binary or fall back to built one
        if [[ "${{ steps.download.outputs.downloaded }}" == "true" ]]; then
           CLI="${{ github.action_path }}/bin/zeckit"
        else
           CLI="${{ github.action_path }}/target/debug/zeckit"
        fi
        
        echo "Using ZecKit CLI at: $CLI"

        # Build optional flags from action inputs
        ZECKIT_UP_EXTRA_ARGS=()
        if [ -n "${{ inputs.miner_address }}" ]; then
          ZECKIT_UP_EXTRA_ARGS+=(--miner-address "${{ inputs.miner_address }}")
        fi
        if [ -n "${{ inputs.fund_address }}" ]; then
          ZECKIT_UP_EXTRA_ARGS+=(--fund-address "${{ inputs.fund_address }}")
        fi
        if [ -n "${{ inputs.block_interval }}" ]; then
          ZECKIT_UP_EXTRA_ARGS+=(--block-interval "${{ inputs.block_interval }}")
        fi
        if [ -n "${{ inputs.activation_heights }}" ]; then
          ZECKIT_UP_EXTRA_ARGS+=(--activation-heights "${{ inputs.activation_heights }}")
        fi

        # Resolve image prefix
        IMAGE_PREFIX="${{ inputs.image_prefix }}"
        if [ -z "$IMAGE_PREFIX" ]; then
           # Detect the repository hosting the action (fork-safe)
           OWNER_REPO=$(echo "${{ github.action_path }}" | awk -F'/_actions/' '{print $2}' | cut -d'/' -f1,2)
           if [ -z "$OWNER_REPO" ]; then
              OWNER_REPO="intelliDean/ZecKit"
           fi
           IMAGE_PREFIX="ghcr.io/$(echo "$OWNER_REPO" | tr '[:upper:]' '[:lower:]')"
        fi
        echo "Resolved image prefix: $IMAGE_PREFIX"

        # Run the devnet
        "$CLI" up \
          --backend "${{ inputs.backend }}" \
          --timeout "${{ inputs.startup_timeout_minutes }}" \
          --action-mode \
          --fund-amount "${{ inputs.fund_amount }}" \
          --image-prefix "$IMAGE_PREFIX" \
          "${ZECKIT_UP_EXTRA_ARGS[@]}"
        
        # Skip test phase if only_setup is true
        if [ "${{ inputs.only_setup }}" = "true" ]; then
          echo "only_setup=true: skipping smoke tests"
          echo "test_result=skip" >> $GITHUB_OUTPUT
          exit 0
        fi
        
        # Disable exit-on-error temporarily so we can parse outputs
        set +e
        
        # Run the tests
        "$CLI" test \
          --amount "${{ inputs.send_amount }}" \
          --memo "${{ inputs.send_memo }}" \
          --action-mode
        
        CLI_EXIT_CODE=$?
        
        # Re-enable exit-on-error
        set -e
        
        # Extract metadata from logs if exists
        if [ -f ~/.zeckit/logs/run-summary.json ]; then
           echo "unified_address=$(jq -r .faucet_address ~/.zeckit/logs/run-summary.json)" >> $GITHUB_OUTPUT
           echo "shield_txid=$(jq -r .shield_txid ~/.zeckit/logs/run-summary.json)" >> $GITHUB_OUTPUT
           echo "send_txid=$(jq -r .send_txid ~/.zeckit/logs/run-summary.json)" >> $GITHUB_OUTPUT
           echo "final_orchard_balance=$(jq -r .final_balance ~/.zeckit/logs/run-summary.json)" >> $GITHUB_OUTPUT
           echo "test_result=$(jq -r .test_result ~/.zeckit/logs/run-summary.json)" >> $GITHUB_OUTPUT
        else
           echo "test_result=fail" >> $GITHUB_OUTPUT
        fi
        
        echo "Exiting with CLI code: $CLI_EXIT_CODE"
        exit $CLI_EXIT_CODE

    - name: Collect Docker Logs
      if: always()
      shell: bash
      run: |
        echo "Collecting container logs..."
        if [ ! -d ~/.zeckit ]; then echo "zeckit devnet never launched successfully - skipping artifact collection"; exit 0; fi
        cd ~/.zeckit
        mkdir -p logs
        docker ps -a > logs/containers.log 2>&1 || true
        docker network ls > logs/networks.log 2>&1 || true
        docker compose -f docker-compose.yml logs zebra-miner > logs/zebra.log 2>&1 || true
        docker compose -f docker-compose.yml logs faucet-${{ inputs.backend }} > logs/faucet.log 2>&1 || true
        docker compose -f docker-compose.yml logs lightwalletd > logs/lightwalletd.log 2>&1 || true
        docker compose -f docker-compose.yml logs zaino > logs/zaino.log 2>&1 || true
        
        # Copy to workspace to avoid relative path tracking error in upload-artifact@v4
        mkdir -p "${{ github.workspace }}/zeckit-e2e-logs-${{ inputs.backend }}"
        cp -r logs/* "${{ github.workspace }}/zeckit-e2e-logs-${{ inputs.backend }}/" || true

    - name: Upload Artifacts
      if: |
        always() &&
        (inputs.upload_artifacts == 'always' || (inputs.upload_artifacts == 'on-failure' && steps.e2e.outputs.test_result != 'pass'))
      uses: actions/upload-artifact@v4
      with:
        name: zeckit-e2e-logs-${{ github.job }}-${{ inputs.backend }}-${{ github.run_number }}
        path: ${{ github.workspace }}/zeckit-e2e-logs-${{ inputs.backend }}/
        retention-days: 14